optimum-rbln 0.9.3rc0__py3-none-any.whl → 0.9.5a4__py3-none-any.whl

optimum/rbln/diffusers/models/unets/unet_2d_condition.py

@@ -171,7 +171,7 @@ class RBLNUNet2DConditionModel(RBLNModel):
             self.add_embedding = ADDEMBEDDING(LINEAR1(self.in_features))
 
     @classmethod
-    def wrap_model_if_needed(
+    def _wrap_model_if_needed(
         cls, model: torch.nn.Module, rbln_config: RBLNUNet2DConditionModelConfig
     ) -> torch.nn.Module:
         if model.config.addition_embed_type == "text_time":
@@ -341,7 +341,7 @@ class RBLNUNet2DConditionModel(RBLNModel):
         timestep_cond: Optional[torch.Tensor] = None,
         attention_mask: Optional[torch.Tensor] = None,
         cross_attention_kwargs: Optional[Dict[str, Any]] = None,
-        added_cond_kwargs: Dict[str, torch.Tensor] = {},
+        added_cond_kwargs: Optional[Dict[str, torch.Tensor]] = None,
         down_block_additional_residuals: Optional[Tuple[torch.Tensor]] = None,
         mid_block_additional_residual: Optional[torch.Tensor] = None,
         down_intrablock_additional_residuals: Optional[Tuple[torch.Tensor]] = None,
@@ -349,6 +349,22 @@ class RBLNUNet2DConditionModel(RBLNModel):
         return_dict: bool = True,
         **kwargs,
     ) -> Union[UNet2DConditionOutput, Tuple]:
+        """
+        Forward pass for the RBLN-optimized UNet2DConditionModel.
+
+        Args:
+            sample (torch.Tensor): The noisy input tensor with the following shape `(batch, channel, height, width)`.
+            timestep (Union[torch.Tensor, float, int]): The number of timesteps to denoise an input.
+            encoder_hidden_states (torch.Tensor): The encoder hidden states.
+            added_cond_kwargs (Dict[str, torch.Tensor]): A kwargs dictionary containing additional embeddings that
+                if specified are added to the embeddings that are passed along to the UNet blocks.
+            down_block_additional_residuals (Optional[Tuple[torch.Tensor]]): A tuple of tensors that if specified are added to the residuals of down unet blocks.
+            mid_block_additional_residual (Optional[torch.Tensor]): A tensor that if specified is added to the residual of the middle unet block.
+            return_dict (bool): Whether or not to return a [`~diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput`] instead of a plain tuple.
+
+        Returns:
+            (Union[`~diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput`], Tuple)
+        """
         sample_batch_size = sample.size()[0]
         compiled_batch_size = self.compiled_batch_size
         if sample_batch_size != compiled_batch_size and (

optimum/rbln/diffusers/models/unets/unet_spatio_temporal_condition.py

@@ -0,0 +1,201 @@
+# Copyright 2025 Rebellions Inc. All rights reserved.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at:
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Dict, Optional, Tuple, Union
+
+import torch
+from diffusers.models.unets.unet_spatio_temporal_condition import (
+    UNetSpatioTemporalConditionModel,
+    UNetSpatioTemporalConditionOutput,
+)
+from transformers import PretrainedConfig
+
+from ....configuration_utils import RBLNCompileConfig
+from ....modeling import RBLNModel
+from ....utils.logging import get_logger
+from ...configurations import RBLNUNetSpatioTemporalConditionModelConfig
+from ...modeling_diffusers import RBLNDiffusionMixin, RBLNDiffusionMixinConfig
+
+
+if TYPE_CHECKING:
+    from transformers import AutoFeatureExtractor, AutoProcessor, PreTrainedModel
+
+logger = get_logger(__name__)
+
+
+class _UNet_STCM(torch.nn.Module):
+    def __init__(self, unet: "UNetSpatioTemporalConditionModel"):
+        super().__init__()
+        self.unet = unet
+
+    def forward(
+        self,
+        sample: torch.Tensor,
+        timestep: Union[torch.Tensor, float, int],
+        encoder_hidden_states: torch.Tensor,
+        added_time_ids: torch.Tensor,
+    ) -> torch.Tensor:
+        unet_out = self.unet(
+            sample=sample,
+            timestep=timestep,
+            encoder_hidden_states=encoder_hidden_states,
+            added_time_ids=added_time_ids,
+            return_dict=False,
+        )
+        return unet_out
+
+
+class RBLNUNetSpatioTemporalConditionModel(RBLNModel):
+    hf_library_name = "diffusers"
+    auto_model_class = UNetSpatioTemporalConditionModel
+    _rbln_config_class = RBLNUNetSpatioTemporalConditionModelConfig
+    output_class = UNetSpatioTemporalConditionOutput
+    output_key = "sample"
+
+    def __post_init__(self, **kwargs):
+        super().__post_init__(**kwargs)
+        self.in_features = self.rbln_config.in_features
+        if self.in_features is not None:
+
+            @dataclass
+            class LINEAR1:
+                in_features: int
+
+            @dataclass
+            class ADDEMBEDDING:
+                linear_1: LINEAR1
+
+            self.add_embedding = ADDEMBEDDING(LINEAR1(self.in_features))
+
+    @classmethod
+    def _wrap_model_if_needed(
+        cls, model: torch.nn.Module, rbln_config: RBLNUNetSpatioTemporalConditionModelConfig
+    ) -> torch.nn.Module:
+        return _UNet_STCM(model).eval()
+
+    @classmethod
+    def get_unet_sample_size(
+        cls,
+        pipe: RBLNDiffusionMixin,
+        rbln_config: RBLNUNetSpatioTemporalConditionModelConfig,
+        image_size: Optional[Tuple[int, int]] = None,
+    ) -> Union[int, Tuple[int, int]]:
+        scale_factor = pipe.vae_scale_factor
+
+        if image_size is None:
+            vae_sample_size = pipe.vae.config.sample_size
+            if isinstance(vae_sample_size, int):
+                vae_sample_size = (vae_sample_size, vae_sample_size)
+
+            sample_size = (
+                vae_sample_size[0] // scale_factor,
+                vae_sample_size[1] // scale_factor,
+            )
+        else:
+            sample_size = (image_size[0] // scale_factor, image_size[1] // scale_factor)
+        return sample_size
+
+    @classmethod
+    def update_rbln_config_using_pipe(
+        cls, pipe: RBLNDiffusionMixin, rbln_config: "RBLNDiffusionMixinConfig", submodule_name: str
+    ) -> Dict[str, Any]:
+        rbln_config.unet.sample_size = cls.get_unet_sample_size(
+            pipe, rbln_config.unet, image_size=rbln_config.image_size
+        )
+        return rbln_config
+
+    @classmethod
+    def _update_rbln_config(
+        cls,
+        preprocessors: Union["AutoFeatureExtractor", "AutoProcessor"],
+        model: "PreTrainedModel",
+        model_config: "PretrainedConfig",
+        rbln_config: RBLNUNetSpatioTemporalConditionModelConfig,
+    ) -> RBLNUNetSpatioTemporalConditionModelConfig:
+        if rbln_config.num_frames is None:
+            rbln_config.num_frames = model_config.num_frames
+
+        if rbln_config.sample_size is None:
+            rbln_config.sample_size = model_config.sample_size
+
+        input_info = [
+            (
+                "sample",
+                [
+                    rbln_config.batch_size,
+                    rbln_config.num_frames,
+                    model_config.in_channels,
+                    rbln_config.sample_size[0],
+                    rbln_config.sample_size[1],
+                ],
+                "float32",
+            ),
+            ("timestep", [], "float32"),
+            ("encoder_hidden_states", [rbln_config.batch_size, 1, model_config.cross_attention_dim], "float32"),
+            ("added_time_ids", [rbln_config.batch_size, 3], "float32"),
+        ]
+
+        if hasattr(model_config, "addition_time_embed_dim"):
+            rbln_config.in_features = model_config.projection_class_embeddings_input_dim
+
+        rbln_compile_config = RBLNCompileConfig(input_info=input_info)
+        rbln_config.set_compile_cfgs([rbln_compile_config])
+
+        return rbln_config
+
+    @property
+    def compiled_batch_size(self):
+        return self.rbln_config.compile_cfgs[0].input_info[0][1][0]
+
+    def forward(
+        self,
+        sample: torch.Tensor,
+        timestep: Union[torch.Tensor, float, int],
+        encoder_hidden_states: torch.Tensor,
+        added_time_ids: torch.Tensor,
+        return_dict: bool = True,
+        **kwargs,
+    ) -> Union[UNetSpatioTemporalConditionOutput, Tuple]:
+        """
+        Forward pass for the RBLN-optimized UNetSpatioTemporalConditionModel.
+
+        Args:
+            sample (torch.Tensor): The noisy input tensor with the following shape `(batch, channel, height, width)`.
+            timestep (Union[torch.Tensor, float, int]): The number of timesteps to denoise an input.
+            encoder_hidden_states (torch.Tensor): The encoder hidden states.
+            added_time_ids (torch.Tensor): A tensor containing additional sinusoidal embeddings and added to the time embeddings.
+            return_dict (bool): Whether or not to return a [`~diffusers.models.unets.unet_spatio_temporal_condition.UNetSpatioTemporalConditionOutput`] instead of a plain tuple.
+
+        Returns:
+            (Union[`~diffusers.models.unets.unet_spatio_temporal_condition.UNetSpatioTemporalConditionOutput`], Tuple)
+        """
+        sample_batch_size = sample.size()[0]
+        compiled_batch_size = self.compiled_batch_size
+        if sample_batch_size != compiled_batch_size and (
+            sample_batch_size * 2 == compiled_batch_size or sample_batch_size == compiled_batch_size * 2
+        ):
+            raise ValueError(
+                f"Mismatch between UNet's runtime batch size ({sample_batch_size}) and compiled batch size ({compiled_batch_size}). "
+                "This may be caused by the 'guidance scale' parameter, which doubles the runtime batch size in Stable Diffusion. "
+                "Adjust the batch size during compilation or modify the 'guidance scale' to match the compiled batch size.\n\n"
+                "For details, see: https://docs.rbln.ai/software/optimum/model_api.html#stable-diffusion"
+            )
+        return super().forward(
+            sample.contiguous(),
+            timestep.float(),
+            encoder_hidden_states,
+            added_time_ids,
+            return_dict=return_dict,
+        )

optimum/rbln/diffusers/pipelines/__init__.py

@@ -59,6 +59,9 @@ _import_structure = {
         "RBLNStableDiffusion3Img2ImgPipeline",
         "RBLNStableDiffusion3InpaintPipeline",
     ],
+    "stable_video_diffusion": [
+        "RBLNStableVideoDiffusionPipeline",
+    ],
 }
 if TYPE_CHECKING:
     from .auto_pipeline import (
@@ -98,6 +101,7 @@ if TYPE_CHECKING:
         RBLNStableDiffusionXLInpaintPipeline,
         RBLNStableDiffusionXLPipeline,
     )
+    from .stable_video_diffusion import RBLNStableVideoDiffusionPipeline
 else:
     import sys
 

optimum/rbln/diffusers/pipelines/auto_pipeline.py

@@ -15,7 +15,7 @@
 
 import importlib
 from pathlib import Path
-from typing import Any, Dict, Type, Union
+from typing import Any, Dict, Optional, Type, Union
 
 from diffusers.models.controlnets import ControlNetUnionModel
 from diffusers.pipelines.auto_pipeline import (
@@ -174,7 +174,7 @@ class RBLNAutoPipelineBase:
         model_id: Union[str, Path],
         *,
         export: bool = None,
-        rbln_config: Union[Dict[str, Any], RBLNModelConfig] = {},
+        rbln_config: Optional[Union[Dict[str, Any], RBLNModelConfig]] = None,
         **kwargs: Any,
     ):
         """

optimum/rbln/diffusers/pipelines/controlnet/multicontrolnet.py

@@ -96,6 +96,26 @@ class RBLNMultiControlNetModel(RBLNModel):
         guess_mode: bool = False,
         return_dict: bool = True,
     ):
+        """
+        Forward pass for the RBLN-optimized MultiControlNetModel.
+
+        This method processes multiple ControlNet models in sequence, applying each one to the input sample
+        with its corresponding conditioning image and scale factor. The outputs from all ControlNets are
+        merged by addition to produce the final control signals.
+
+        Args:
+            sample (torch.FloatTensor): The noisy input tensor.
+            timestep (Union[torch.Tensor, float, int]): The number of timesteps to denoise an input.
+            encoder_hidden_states (torch.Tensor): The encoder hidden states from the text encoder.
+            controlnet_cond (List[torch.Tensor]): A list of conditional input tensors, one for each ControlNet model.
+            conditioning_scale (List[float]): A list of scale factors for each ControlNet output. Each scale
+                controls the strength of the corresponding ControlNet's influence on the generation.
+            return_dict (bool): Whether or not to return a dictionary instead of a plain tuple. Currently,
+                this method always returns a tuple regardless of this parameter.
+
+        Returns:
+            (Tuple[List[torch.Tensor], torch.Tensor])
+        """
         for i, (image, scale, controlnet) in enumerate(zip(controlnet_cond, conditioning_scale, self.nets)):
             down_samples, mid_sample = controlnet(
                 sample=sample.contiguous(),

optimum/rbln/diffusers/pipelines/controlnet/pipeline_controlnet.py

@@ -151,7 +151,9 @@ class RBLNStableDiffusionControlNetPipeline(RBLNDiffusionMixin, StableDiffusionC
             for image_ in image:
                 self.check_image(image_, prompt, prompt_embeds)
         else:
-            assert False
+            raise TypeError(
+                "Unsupported controlnet type. Expected `RBLNControlNetModel` or `RBLNMultiControlNetModel`."
+            )
 
         # Check `controlnet_conditioning_scale`
         if (
@@ -180,7 +182,9 @@ class RBLNStableDiffusionControlNetPipeline(RBLNDiffusionMixin, StableDiffusionC
                     " the same length as the number of controlnets"
                 )
         else:
-            assert False
+            raise TypeError(
+                "Unsupported controlnet type. Expected `RBLNControlNetModel` or `RBLNMultiControlNetModel`."
+            )
 
         if not isinstance(control_guidance_start, (tuple, list)):
             control_guidance_start = [control_guidance_start]
@@ -254,7 +258,7 @@ class RBLNStableDiffusionControlNetPipeline(RBLNDiffusionMixin, StableDiffusionC
         control_guidance_end: Union[float, List[float]] = 1.0,
         clip_skip: Optional[int] = None,
         callback_on_step_end: Optional[Callable[[int, int, Dict], None]] = None,
-        callback_on_step_end_tensor_inputs: List[str] = ["latents"],
+        callback_on_step_end_tensor_inputs: Optional[List[str]] = None,
         **kwargs,
     ):
         r"""
@@ -393,6 +397,9 @@ class RBLNStableDiffusionControlNetPipeline(RBLNDiffusionMixin, StableDiffusionC
             )
 
         # 1. Check inputs. Raise error if not correct
+        if callback_on_step_end_tensor_inputs is None:
+            callback_on_step_end_tensor_inputs = ["latents"]
+
         self.check_inputs(
             prompt,
             image,
@@ -503,7 +510,9 @@ class RBLNStableDiffusionControlNetPipeline(RBLNDiffusionMixin, StableDiffusionC
             image = images
             height, width = image[0].shape[-2:]
         else:
-            assert False
+            raise TypeError(
+                "Unsupported controlnet type. Expected `RBLNControlNetModel` or `RBLNMultiControlNetModel`."
+            )
 
         # 5. Prepare timesteps
         timesteps, num_inference_steps = retrieve_timesteps(self.scheduler, num_inference_steps, device, timesteps)

optimum/rbln/diffusers/pipelines/controlnet/pipeline_controlnet_img2img.py

@@ -152,7 +152,9 @@ class RBLNStableDiffusionControlNetImg2ImgPipeline(RBLNDiffusionMixin, StableDif
             for image_ in image:
                 self.check_image(image_, prompt, prompt_embeds)
         else:
-            assert False
+            raise TypeError(
+                "Unsupported controlnet type. Expected `RBLNControlNetModel` or `RBLNMultiControlNetModel`."
+            )
 
         # Check `controlnet_conditioning_scale`
         if (
@@ -178,7 +180,9 @@ class RBLNStableDiffusionControlNetImg2ImgPipeline(RBLNDiffusionMixin, StableDif
                     " the same length as the number of controlnets"
                 )
         else:
-            assert False
+            raise TypeError(
+                "Unsupported controlnet type. Expected `RBLNControlNetModel` or `RBLNMultiControlNetModel`."
+            )
 
         if len(control_guidance_start) != len(control_guidance_end):
             raise ValueError(
@@ -247,7 +251,7 @@ class RBLNStableDiffusionControlNetImg2ImgPipeline(RBLNDiffusionMixin, StableDif
         control_guidance_end: Union[float, List[float]] = 1.0,
         clip_skip: Optional[int] = None,
         callback_on_step_end: Optional[Callable[[int, int, Dict], None]] = None,
-        callback_on_step_end_tensor_inputs: List[str] = ["latents"],
+        callback_on_step_end_tensor_inputs: Optional[List[str]] = None,
         **kwargs,
     ):
         r"""
@@ -384,6 +388,9 @@ class RBLNStableDiffusionControlNetImg2ImgPipeline(RBLNDiffusionMixin, StableDif
             )
 
         # 1. Check inputs. Raise error if not correct
+        if callback_on_step_end_tensor_inputs is None:
+            callback_on_step_end_tensor_inputs = ["latents"]
+
         self.check_inputs(
             prompt,
             control_image,
@@ -490,7 +497,9 @@ class RBLNStableDiffusionControlNetImg2ImgPipeline(RBLNDiffusionMixin, StableDif
 
             control_image = control_images
         else:
-            assert False
+            raise TypeError(
+                "Unsupported controlnet type. Expected `RBLNControlNetModel` or `RBLNMultiControlNetModel`."
+            )
 
         # 5. Prepare timesteps
         self.scheduler.set_timesteps(num_inference_steps, device=device)

optimum/rbln/diffusers/pipelines/controlnet/pipeline_controlnet_sd_xl.py

@@ -178,7 +178,9 @@ class RBLNStableDiffusionXLControlNetPipeline(RBLNDiffusionMixin, StableDiffusio
             for image_ in image:
                 self.check_image(image_, prompt, prompt_embeds)
         else:
-            assert False
+            raise TypeError(
+                "Unsupported controlnet type. Expected `RBLNControlNetModel` or `RBLNMultiControlNetModel`."
+            )
 
         # Check `controlnet_conditioning_scale`
         if (
@@ -204,7 +206,9 @@ class RBLNStableDiffusionXLControlNetPipeline(RBLNDiffusionMixin, StableDiffusio
                     " the same length as the number of controlnets"
                 )
         else:
-            assert False
+            raise TypeError(
+                "Unsupported controlnet type. Expected `RBLNControlNetModel` or `RBLNMultiControlNetModel`."
+            )
 
         if not isinstance(control_guidance_start, (tuple, list)):
             control_guidance_start = [control_guidance_start]
@@ -288,7 +292,7 @@ class RBLNStableDiffusionXLControlNetPipeline(RBLNDiffusionMixin, StableDiffusio
         negative_target_size: Optional[Tuple[int, int]] = None,
         clip_skip: Optional[int] = None,
         callback_on_step_end: Optional[Callable[[int, int, Dict], None]] = None,
-        callback_on_step_end_tensor_inputs: List[str] = ["latents"],
+        callback_on_step_end_tensor_inputs: Optional[List[str]] = None,
         **kwargs,
     ):
         r"""
@@ -466,6 +470,9 @@ class RBLNStableDiffusionXLControlNetPipeline(RBLNDiffusionMixin, StableDiffusio
             )
 
         # 1. Check inputs. Raise error if not correct
+        if callback_on_step_end_tensor_inputs is None:
+            callback_on_step_end_tensor_inputs = ["latents"]
+
         self.check_inputs(
             prompt,
             prompt_2,
@@ -581,7 +588,9 @@ class RBLNStableDiffusionXLControlNetPipeline(RBLNDiffusionMixin, StableDiffusio
             image = images
             height, width = image[0].shape[-2:]
         else:
-            assert False
+            raise TypeError(
+                "Unsupported controlnet type. Expected `RBLNControlNetModel` or `RBLNMultiControlNetModel`."
+            )
 
         # 5. Prepare timesteps
         self.scheduler.set_timesteps(num_inference_steps, device=device)

optimum/rbln/diffusers/pipelines/controlnet/pipeline_controlnet_sd_xl_img2img.py

@@ -190,7 +190,9 @@ class RBLNStableDiffusionXLControlNetImg2ImgPipeline(RBLNDiffusionMixin, StableD
             for image_ in image:
                 self.check_image(image_, prompt, prompt_embeds)
         else:
-            assert False
+            raise TypeError(
+                "Unsupported controlnet type. Expected `RBLNControlNetModel` or `RBLNMultiControlNetModel`."
+            )
 
         # Check `controlnet_conditioning_scale`
         if (
@@ -216,7 +218,9 @@ class RBLNStableDiffusionXLControlNetImg2ImgPipeline(RBLNDiffusionMixin, StableD
                     " the same length as the number of controlnets"
                 )
         else:
-            assert False
+            raise TypeError(
+                "Unsupported controlnet type. Expected `RBLNControlNetModel` or `RBLNMultiControlNetModel`."
+            )
 
         if not isinstance(control_guidance_start, (tuple, list)):
             control_guidance_start = [control_guidance_start]
@@ -303,7 +307,7 @@ class RBLNStableDiffusionXLControlNetImg2ImgPipeline(RBLNDiffusionMixin, StableD
         negative_aesthetic_score: float = 2.5,
         clip_skip: Optional[int] = None,
         callback_on_step_end: Optional[Callable[[int, int, Dict], None]] = None,
-        callback_on_step_end_tensor_inputs: List[str] = ["latents"],
+        callback_on_step_end_tensor_inputs: Optional[List[str]] = None,
         **kwargs,
     ):
         r"""
@@ -500,6 +504,9 @@ class RBLNStableDiffusionXLControlNetImg2ImgPipeline(RBLNDiffusionMixin, StableD
             )
 
         # 1. Check inputs. Raise error if not correct
+        if callback_on_step_end_tensor_inputs is None:
+            callback_on_step_end_tensor_inputs = ["latents"]
+
         self.check_inputs(
             prompt,
             prompt_2,
@@ -618,7 +625,9 @@ class RBLNStableDiffusionXLControlNetImg2ImgPipeline(RBLNDiffusionMixin, StableD
             control_image = control_images
             height, width = control_image[0].shape[-2:]
         else:
-            assert False
+            raise TypeError(
+                "Unsupported controlnet type. Expected `RBLNControlNetModel` or `RBLNMultiControlNetModel`."
+            )
 
         # 5. Prepare timesteps
         self.scheduler.set_timesteps(num_inference_steps, device=device)

optimum/rbln/diffusers/pipelines/cosmos/cosmos_guardrail.py

@@ -81,7 +81,7 @@ def is_compiled_dir(dir: str) -> bool:
     if not os.path.exists(dir):
         return False
 
-    for root, dirs, files in os.walk(dir):
+    for _, _, files in os.walk(dir):
         for file in files:
             if file.endswith(".rbln"):
                 return True

optimum/rbln/diffusers/pipelines/cosmos/pipeline_cosmos_text2world.py

@@ -86,7 +86,7 @@ class RBLNCosmosTextToWorldPipeline(RBLNDiffusionMixin, CosmosTextToWorldPipelin
         *,
         export: bool = False,
         safety_checker: Optional[RBLNCosmosSafetyChecker] = None,
-        rbln_config: Dict[str, Any] = {},
+        rbln_config: Optional[Dict[str, Any]] = None,
         **kwargs: Any,
     ):
         """

optimum/rbln/diffusers/pipelines/cosmos/pipeline_cosmos_video2world.py

@@ -86,7 +86,7 @@ class RBLNCosmosVideoToWorldPipeline(RBLNDiffusionMixin, CosmosVideoToWorldPipel
         *,
         export: bool = False,
         safety_checker: Optional[RBLNCosmosSafetyChecker] = None,
-        rbln_config: Dict[str, Any] = {},
+        rbln_config: Optional[Dict[str, Any]] = None,
         **kwargs: Any,
     ):
         """
@@ -118,7 +118,6 @@ class RBLNCosmosVideoToWorldPipeline(RBLNDiffusionMixin, CosmosVideoToWorldPipel
                 RBLN compilation process. These may include parameters specific to individual submodules
                 or the particular diffusion pipeline being used.
         """
-
         rbln_config, kwargs = cls.get_rbln_config_class().initialize_from_kwargs(rbln_config, **kwargs)
         if safety_checker is None and export:
             safety_checker = RBLNCosmosSafetyChecker(rbln_config=rbln_config.safety_checker)

optimum/rbln/diffusers/pipelines/stable_video_diffusion/__init__.py

@@ -0,0 +1,15 @@
+# Copyright 2025 Rebellions Inc. All rights reserved.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at:
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .pipeline_stable_video_diffusion import RBLNStableVideoDiffusionPipeline

optimum/rbln/diffusers/pipelines/stable_video_diffusion/pipeline_stable_video_diffusion.py

@@ -0,0 +1,46 @@
+# Copyright 2025 Rebellions Inc. All rights reserved.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at:
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+from diffusers import StableVideoDiffusionPipeline
+
+from ....utils.logging import get_logger
+from ...configurations import RBLNStableVideoDiffusionPipelineConfig
+from ...modeling_diffusers import RBLNDiffusionMixin
+
+
+logger = get_logger(__name__)
+
+
+class RBLNStableVideoDiffusionPipeline(RBLNDiffusionMixin, StableVideoDiffusionPipeline):
+    """
+    RBLN-accelerated implementation of Stable Video Diffusion pipeline for image-to-video generation.
+
+    This pipeline compiles Stable Video Diffusion models to run efficiently on RBLN NPUs, enabling high-performance
+    inference for generating videos from images with optimized memory usage and throughput.
+    """
+
+    original_class = StableVideoDiffusionPipeline
+    _rbln_config_class = RBLNStableVideoDiffusionPipelineConfig
+    _submodules = ["image_encoder", "unet", "vae"]
+
+    def handle_additional_kwargs(self, **kwargs):
+        compiled_num_frames = self.unet.rbln_config.num_frames
+        if compiled_num_frames is not None:
+            kwargs["num_frames"] = compiled_num_frames
+
+        compiled_decode_chunk_size = self.vae.rbln_config.decode_chunk_size
+        if compiled_decode_chunk_size is not None:
+            kwargs["decode_chunk_size"] = compiled_decode_chunk_size
+        return kwargs