One obsession text encoder

[xalteropsx]

https://civitai.com/models/2695493/one-obsessionanima

how can we load this model using diffuser it has textencoder and vae but
do we have to use CosmosTransformer3DModel ,
but i dont understand they have text encoder as well as vae and diffuser dont seems to have singlefile support ?

Please load the component before passing it in as an argument to `from_single_file`.

text_encoder = CLIPTextModel.from_pretrained('...')
pipe = StableDiffusionPipeline.from_single_file(<checkpoint path>, text_encoder=text_encoder)

[Arthur031221]

The component names in that checkpoint (qwen_3_06b_base.safetensors as text encoder, qwen_image_vae.safetensors as VAE) point to this being a Qwen-Image based checkpoint, not Cosmos, whatever base-model tag Civitai shows on the page. CosmosTransformer3DModel is the wrong class for it, that's a different model family entirely, and it's why StableDiffusionPipeline.from_single_file doesn't work either, that pipeline expects a UNet + CLIP text encoder, neither of which this checkpoint has.

I checked what's actually in diffusers 0.40.0 (pip install diffusers) for the Qwen-Image family. QwenImageTransformer2DModel is single-file loadable, it's listed in diffusers/loaders/single_file_model.py's SINGLE_FILE_LOADABLE_CLASSES with an identity checkpoint mapping (no key renaming needed):

from diffusers import QwenImageTransformer2DModel
transformer = QwenImageTransformer2DModel.from_single_file("Ob_animaV4.safetensors")  # works

AutoencoderKLQwenImage is not in that list, so calling .from_single_file() on it raises right away:

from diffusers import AutoencoderKLQwenImage
AutoencoderKLQwenImage.from_single_file("qwen_image_vae.safetensors")
# ValueError: FromOriginalModelMixin is currently only compatible with StableCascadeUNet,
# UNet2DConditionModel, AutoencoderKL, ... (QwenImageTransformer2DModel is in the list, this VAE isn't)

The workaround I actually got working is building the VAE from its published config and loading the safetensors weights into it directly, bypassing from_single_file entirely. I tested this against the official Qwen/Qwen-Image vae weights (same file name, qwen_image_vae.safetensors, so almost certainly the same architecture your checkpoint's VAE was exported from):

from diffusers import AutoencoderKLQwenImage
from safetensors.torch import load_file

cfg = AutoencoderKLQwenImage.load_config("Qwen/Qwen-Image", subfolder="vae")
vae = AutoencoderKLQwenImage.from_config(cfg)
result = vae.load_state_dict(load_file("qwen_image_vae.safetensors"))
print(result)  # <All keys matched successfully>

That loaded with zero missing and zero unexpected keys, strict load, no manual key renaming needed. If your qwen_image_vae.safetensors is byte-for-byte the stock Qwen-Image VAE (which the shared file name suggests), this same snippet should load it the same way.

QwenImagePipeline.from_single_file doesn't exist either (no such method), there's no single call that loads the whole pipeline from one file the way StableDiffusionPipeline.from_single_file does for SD1.5. You'd assemble it component by component:

pipe = QwenImagePipeline(transformer=transformer, vae=vae, text_encoder=..., tokenizer=..., scheduler=...)

The part I'd flag before you go further: QwenImagePipeline.__init__ expects text_encoder: Qwen2_5_VLForConditionalGeneration and tokenizer: Qwen2Tokenizer, that's the 7B Qwen2.5-VL used by the official Qwen-Image release. Your checkpoint ships qwen_3_06b_base, a much smaller plain Qwen3 model, not Qwen2.5-VL. If that's really a different, smaller text encoder swapped in by whoever built this checkpoint, QwenImagePipeline as shipped in diffusers won't accept it as a drop-in replacement, the class check and the VL-specific prompt encoding in encode_prompt are written against Qwen2.5-VL. You'd need to know the exact class that produced qwen_3_06b_base.safetensors and, most likely, write a small custom pipeline subclass that swaps in that text encoder and its own prompt encoding, rather than expecting from_pretrained/from_single_file on the stock QwenImagePipeline to accept it.

[xalteropsx]

transformer = QwenImageTransformer2DModel.from_single_file('oneObsession3D_v10Anima3d.safetensors',config= 'arc/transformerconfig.json')
i dont but this keep failing i loaded the transformer config correctly from anima

    self.proj_out = nn.Linear(self.inner_dim, patch_size * patch_size * self.out_channels, bias=True)
                                              ~~~~~~~~~~~^~~~~~~~~~~~
TypeError: can't multiply sequence by non-int of type 'list'

[Icaro0310]

Anima is a Cosmos Predict2 finetune, so CosmosTransformer3DModel is right. That error isn't about missing weights, it's from_single_file telling you it can't map a text_encoder out of this checkpoint, so you load one yourself and pass it in:

import torch
from transformers import AutoModelForTextEncoding
from diffusers import AutoPipelineForText2Video

text_encoder = AutoModelForTextEncoding.from_pretrained(
 "nvidia/Cosmos-Predict2-2B-Text2World"
 subfolder="text_encoder"
 torch_dtype=torch.bfloat16
)
pipe = AutoPipelineForText2Video.from_single_file(
 "one-obsession.safetensors"
 text_encoder=text_encoder
 torch_dtype=torch.bfloat16
)

If it complains about vae next, same trick: load it from that same nvidia repo and pass vae=. You need a fairly recent diffusers for the Cosmos2 single-file mapping, and if autodetect picks the wrong class, try Cosmos2TextToImagePipeline directly (the name is misleading, it does video via num_frames).

—
Check out my Repositories: github.com/Icaro0310 · Website: icaro0310.github.io

[xalteropsx]

doesnt it has single_file pipeline for text_encoder? also AutoPipelineForText2Video doesnt existed in v0.39 in diffuser

[sebxt]

One Obsession is an Anima finetune, and Anima is not Qwen-Image. Diffusers supports it as a modular pipeline (AnimaModularPipeline, in 0.40.0 and later). It uses CosmosTransformer3DModel together with an AnimaTextConditioner (the "LLM adapter"), a Qwen3 0.6B text encoder and the Qwen-Image VAE (docs). The QwenImageTransformer2DModel error you hit is expected, because that class is the wrong architecture for this file.

There is no from_single_file for the whole pipeline, so build it from the official Diffusers repo and swap in the Civitai weights:

• Transformer: CosmosTransformer3DModel is single-file loadable (source).
• Text conditioner: the same checkpoint also contains it under net.llm_adapter.*. The single-file loader skips those keys and only logs a warning (source). Load them yourself the same way the repo's conversion script splits them (source). This matters for a finetune, because the adapter is usually trained too.
• Text encoder: the _txt file is a plain Qwen3 state dict with a model. prefix (source).
• VAE: the Civitai one is the stock qwen_image_vae, so the repo's vae works as is.

import torch
from safetensors.torch import load_file
from transformers import AutoConfig, Qwen3Model
from diffusers import ModularPipeline, CosmosTransformer3DModel, AnimaTextConditioner

BASE = "circlestone-labs/Anima-Base-v1.0-Diffusers"
ckpt = "oneObsessionAnima_v40.safetensors"
te_ckpt = "oneObsessionAnima_v40_txt.safetensors"
dtype = torch.bfloat16

transformer = CosmosTransformer3DModel.from_single_file(
    ckpt, config=BASE, subfolder="transformer", torch_dtype=dtype
)

sd = load_file(ckpt)
adapter = {k.removeprefix("net.llm_adapter."): v for k, v in sd.items() if k.startswith("net.llm_adapter.")}
text_conditioner = AnimaTextConditioner.from_config(
    AnimaTextConditioner.load_config(BASE, subfolder="text_conditioner")
)
text_conditioner.load_state_dict(adapter, strict=True)

te_sd = {k.removeprefix("model."): v for k, v in load_file(te_ckpt).items()}
text_encoder = Qwen3Model(AutoConfig.from_pretrained(BASE, subfolder="text_encoder"))
text_encoder.load_state_dict(te_sd, strict=True)

pipe = ModularPipeline.from_pretrained(BASE)
pipe.load_components(names=["tokenizer", "t5_tokenizer", "vae", "scheduler"], dtype=dtype)
pipe.update_components(
    transformer=transformer,
    text_conditioner=text_conditioner.to(dtype),
    text_encoder=text_encoder.to(dtype),
)
pipe.to("cuda")

image = pipe(
    prompt="masterpiece, best quality, 1girl, solo, city lights",
    negative_prompt="worst quality, low quality, blurry, jpeg artifacts",
).images[0]

I ran this on diffusers 0.41.0 with the original ComfyUI style Anima files. Those use the same layout as the Civitai ones: anima-base-v1.0.safetensors and qwen_3_06b_base.safetensors. Results:

• Both strict loads reported all keys matched.
• The only keys the transformer skipped were the 118 llm_adapter ones.
• The converted transformer matched the repo's conversion script output exactly.
• A 512x512 image generated fine.

Two notes:

• Install torchvision. The Cosmos transformer needs it at inference time (source), and without it you get NameError: name 'transforms' is not defined.
• If you'd rather convert once and save, scripts/convert_anima_to_diffusers.py takes the same three files and writes a normal Diffusers folder.