OzzyGT/Kimodo_SOMA_RP_v1_2_sdnq_dynamic_8bit

Kimodo SOMA RP v1.2 SDNQ INT8

bf16	INT8

Left: original bf16 · Right: this INT8 model (same prompt and seed).

This is a dynamic 8-bit quantized version of OzzyGT/Kimodo_SOMA_RP_v1_2, the Diffusers conversion of NVIDIA's Kimodo SOMA RP v1.2, using SDNQ. The Llama 3 / LLM2Vec text encoder and the motion transformer are quantized; the LLM2Vec supervised LoRA adapter stays in float32 and the motion codec is unchanged. The repository is 8.0 GB instead of 16 GB. Built with Meta Llama 3.

At 8 bits the motion matches bf16: the same seed gives the same take, with joint positions within 1 cm.

Note: You need SDNQ v0.2.8 or superior.

Usage

Install PyTorch for your GPU, then:

pip install diffusers==0.41.0 transformers==5.20.2 peft==0.21.2 "accelerate>=1.15" "safetensors>=0.8" numpy "sdnq>=0.2.8"

The model runs with the Kimodo SOMA Modular blocks, with components_repo pointing at this repository. Import sdnq before loading so the quantized weights are registered. The sample below peaked at 8.2 GiB of VRAM.

The example uses trust_remote_code=True and trust_components_code=True.

Note: both flags run Python code downloaded from the Hub: trust_remote_code=True runs the code of the blocks repository, and trust_components_code=True runs the code shipped in the components_repo. Only use them with repositories you trust, and review their code before passing different ones.

For model details and prompting, see the original model card and Kimodo repository.

Sample motion

The INT8 motion above was generated with the following prompt and settings (seed 42):

import numpy as np
import sdnq  # noqa: F401
import torch
from diffusers import ModularPipelineBlocks


blocks = ModularPipelineBlocks.from_pretrained(
    "OzzyGT/Kimodo_SOMA_Modular",
    trust_remote_code=True,
    components_repo="OzzyGT/Kimodo_SOMA_RP_v1_2_sdnq_dynamic_8bit",
    trust_components_code=True,
)
pipe = blocks.init_pipeline()
pipe.load_components(dtype={"text_encoder": torch.bfloat16, "default": torch.float32})
pipe.to("cuda")

motion = pipe(
    prompt="A person runs forward at a steady pace.",
    num_frames=120,
    seed=42,
    num_inference_steps=100,
    output="motion",
)
np.savez_compressed(
    "motion_int8.npz",
    **{key: value[0].cpu().numpy() for key, value in motion.items()},
)

This generates four seconds at 30 FPS. Output uses meters, +Y up, initial +Z forward, and the SOMA77 skeleton, with root motion preserved. Negative prompts are not supported.

Licenses

• Motion weights: NVIDIA Open Model License, from nvidia/Kimodo-SOMA-RP-v1.2.
• Text encoder: Meta Llama 3 Community License and Acceptable Use Policy. Based on Meta Llama 3 8B Instruct with the LLM2Vec MNTP and supervised adapters.
• Custom model code: Apache-2.0. Adapted LLM2Vec code retains its MIT license. See NOTICE for attribution.