From 014d47bac23878f30facce0f03e3bc85837c2ce4 Mon Sep 17 00:00:00 2001 From: DN6 Date: Thu, 26 Mar 2026 17:00:09 +0530 Subject: [PATCH 1/2] update --- .../test_models_transformer_lumina.py | 113 ++++++++---------- .../test_models_transformer_lumina2.py | 83 +++++++------ .../test_models_transformer_mochi.py | 87 ++++++++------ .../test_models_transformer_omnigen.py | 98 +++++++++------ .../test_models_transformer_skyreels_v2.py | 85 +++++++------ 5 files changed, 262 insertions(+), 204 deletions(-) diff --git a/tests/models/transformers/test_models_transformer_lumina.py b/tests/models/transformers/test_models_transformer_lumina.py index 0024aa106c6d..e68a06fbb77d 100644 --- a/tests/models/transformers/test_models_transformer_lumina.py +++ b/tests/models/transformers/test_models_transformer_lumina.py @@ -13,85 +13,46 @@ # See the License for the specific language governing permissions and # limitations under the License. -import unittest - import torch from diffusers import LuminaNextDiT2DModel - -from ...testing_utils import ( - enable_full_determinism, - torch_device, +from diffusers.utils.torch_utils import randn_tensor + +from ...testing_utils import enable_full_determinism, torch_device +from ..testing_utils import ( + BaseModelTesterConfig, + ModelTesterMixin, + TorchCompileTesterMixin, + TrainingTesterMixin, ) -from ..test_modeling_common import ModelTesterMixin enable_full_determinism() -class LuminaNextDiT2DModelTransformerTests(ModelTesterMixin, unittest.TestCase): - model_class = LuminaNextDiT2DModel - main_input_name = "hidden_states" - uses_custom_attn_processor = True - +class LuminaNextDiTTesterConfig(BaseModelTesterConfig): @property - def dummy_input(self): - """ - Args: - None - Returns: - Dict: Dictionary of dummy input tensors - """ - batch_size = 2 # N - num_channels = 4 # C - height = width = 16 # H, W - embedding_dim = 32 # D - sequence_length = 16 # L - - hidden_states = torch.randn((batch_size, num_channels, height, width)).to(torch_device) - encoder_hidden_states = torch.randn((batch_size, sequence_length, embedding_dim)).to(torch_device) - timestep = torch.rand(size=(batch_size,)).to(torch_device) - encoder_mask = torch.randn(size=(batch_size, sequence_length)).to(torch_device) - image_rotary_emb = torch.randn((384, 384, 4)).to(torch_device) + def model_class(self): + return LuminaNextDiT2DModel - return { - "hidden_states": hidden_states, - "encoder_hidden_states": encoder_hidden_states, - "timestep": timestep, - "encoder_mask": encoder_mask, - "image_rotary_emb": image_rotary_emb, - "cross_attention_kwargs": {}, - } + @property + def main_input_name(self) -> str: + return "hidden_states" @property - def input_shape(self): - """ - Args: - None - Returns: - Tuple: (int, int, int) - """ + def output_shape(self) -> tuple: return (4, 16, 16) @property - def output_shape(self): - """ - Args: - None - Returns: - Tuple: (int, int, int) - """ + def input_shape(self) -> tuple: return (4, 16, 16) - def prepare_init_args_and_inputs_for_common(self): - """ - Args: - None + @property + def generator(self): + return torch.Generator("cpu").manual_seed(0) - Returns: - Tuple: (Dict, Dict) - """ - init_dict = { + def get_init_dict(self) -> dict: + return { "sample_size": 16, "patch_size": 2, "in_channels": 4, @@ -108,5 +69,33 @@ def prepare_init_args_and_inputs_for_common(self): "scaling_factor": 1.0, } - inputs_dict = self.dummy_input - return init_dict, inputs_dict + def get_dummy_inputs(self, batch_size: int = 2) -> dict[str, torch.Tensor]: + num_channels = 4 + height = width = 16 + embedding_dim = 32 + sequence_length = 16 + + return { + "hidden_states": randn_tensor( + (batch_size, num_channels, height, width), generator=self.generator, device=torch_device + ), + "encoder_hidden_states": randn_tensor( + (batch_size, sequence_length, embedding_dim), generator=self.generator, device=torch_device + ), + "timestep": torch.rand(size=(batch_size,), generator=self.generator).to(torch_device), + "encoder_mask": randn_tensor((batch_size, sequence_length), generator=self.generator, device=torch_device), + "image_rotary_emb": randn_tensor((384, 384, 4), generator=self.generator, device=torch_device), + "cross_attention_kwargs": {}, + } + + +class TestLuminaNextDiT(LuminaNextDiTTesterConfig, ModelTesterMixin): + pass + + +class TestLuminaNextDiTTraining(LuminaNextDiTTesterConfig, TrainingTesterMixin): + pass + + +class TestLuminaNextDiTCompile(LuminaNextDiTTesterConfig, TorchCompileTesterMixin): + pass diff --git a/tests/models/transformers/test_models_transformer_lumina2.py b/tests/models/transformers/test_models_transformer_lumina2.py index 4efae3d4b713..ea1b52631ba8 100644 --- a/tests/models/transformers/test_models_transformer_lumina2.py +++ b/tests/models/transformers/test_models_transformer_lumina2.py @@ -13,57 +13,46 @@ # See the License for the specific language governing permissions and # limitations under the License. -import unittest - import torch from diffusers import Lumina2Transformer2DModel - -from ...testing_utils import ( - enable_full_determinism, - torch_device, +from diffusers.utils.torch_utils import randn_tensor + +from ...testing_utils import enable_full_determinism, torch_device +from ..testing_utils import ( + BaseModelTesterConfig, + ModelTesterMixin, + TorchCompileTesterMixin, + TrainingTesterMixin, ) -from ..test_modeling_common import ModelTesterMixin enable_full_determinism() -class Lumina2Transformer2DModelTransformerTests(ModelTesterMixin, unittest.TestCase): - model_class = Lumina2Transformer2DModel - main_input_name = "hidden_states" - uses_custom_attn_processor = True - +class Lumina2TransformerTesterConfig(BaseModelTesterConfig): @property - def dummy_input(self): - batch_size = 2 # N - num_channels = 4 # C - height = width = 16 # H, W - embedding_dim = 32 # D - sequence_length = 16 # L - - hidden_states = torch.randn((batch_size, num_channels, height, width)).to(torch_device) - encoder_hidden_states = torch.randn((batch_size, sequence_length, embedding_dim)).to(torch_device) - timestep = torch.rand(size=(batch_size,)).to(torch_device) - attention_mask = torch.ones(size=(batch_size, sequence_length), dtype=torch.bool).to(torch_device) + def model_class(self): + return Lumina2Transformer2DModel - return { - "hidden_states": hidden_states, - "encoder_hidden_states": encoder_hidden_states, - "timestep": timestep, - "encoder_attention_mask": attention_mask, - } + @property + def main_input_name(self) -> str: + return "hidden_states" @property - def input_shape(self): + def output_shape(self) -> tuple: return (4, 16, 16) @property - def output_shape(self): + def input_shape(self) -> tuple: return (4, 16, 16) - def prepare_init_args_and_inputs_for_common(self): - init_dict = { + @property + def generator(self): + return torch.Generator("cpu").manual_seed(0) + + def get_init_dict(self) -> dict: + return { "sample_size": 16, "patch_size": 2, "in_channels": 4, @@ -81,9 +70,33 @@ def prepare_init_args_and_inputs_for_common(self): "cap_feat_dim": 32, } - inputs_dict = self.dummy_input - return init_dict, inputs_dict + def get_dummy_inputs(self, batch_size: int = 2) -> dict[str, torch.Tensor]: + num_channels = 4 + height = width = 16 + embedding_dim = 32 + sequence_length = 16 + return { + "hidden_states": randn_tensor( + (batch_size, num_channels, height, width), generator=self.generator, device=torch_device + ), + "encoder_hidden_states": randn_tensor( + (batch_size, sequence_length, embedding_dim), generator=self.generator, device=torch_device + ), + "timestep": torch.rand(size=(batch_size,), generator=self.generator).to(torch_device), + "encoder_attention_mask": torch.ones((batch_size, sequence_length), dtype=torch.bool, device=torch_device), + } + + +class TestLumina2Transformer(Lumina2TransformerTesterConfig, ModelTesterMixin): + pass + + +class TestLumina2TransformerTraining(Lumina2TransformerTesterConfig, TrainingTesterMixin): def test_gradient_checkpointing_is_applied(self): expected_set = {"Lumina2Transformer2DModel"} super().test_gradient_checkpointing_is_applied(expected_set=expected_set) + + +class TestLumina2TransformerCompile(Lumina2TransformerTesterConfig, TorchCompileTesterMixin): + pass diff --git a/tests/models/transformers/test_models_transformer_mochi.py b/tests/models/transformers/test_models_transformer_mochi.py index 931b5874ee78..fe6ea8be5533 100644 --- a/tests/models/transformers/test_models_transformer_mochi.py +++ b/tests/models/transformers/test_models_transformer_mochi.py @@ -13,58 +13,50 @@ # See the License for the specific language governing permissions and # limitations under the License. -import unittest - import torch from diffusers import MochiTransformer3DModel +from diffusers.utils.torch_utils import randn_tensor from ...testing_utils import enable_full_determinism, torch_device -from ..test_modeling_common import ModelTesterMixin +from ..testing_utils import ( + BaseModelTesterConfig, + ModelTesterMixin, + TorchCompileTesterMixin, + TrainingTesterMixin, +) enable_full_determinism() -class MochiTransformerTests(ModelTesterMixin, unittest.TestCase): - model_class = MochiTransformer3DModel - main_input_name = "hidden_states" - uses_custom_attn_processor = True - # Overriding it because of the transformer size. - model_split_percents = [0.7, 0.6, 0.6] - +class MochiTransformerTesterConfig(BaseModelTesterConfig): @property - def dummy_input(self): - batch_size = 2 - num_channels = 4 - num_frames = 2 - height = 16 - width = 16 - embedding_dim = 16 - sequence_length = 16 + def model_class(self): + return MochiTransformer3DModel - hidden_states = torch.randn((batch_size, num_channels, num_frames, height, width)).to(torch_device) - encoder_hidden_states = torch.randn((batch_size, sequence_length, embedding_dim)).to(torch_device) - encoder_attention_mask = torch.ones((batch_size, sequence_length)).bool().to(torch_device) - timestep = torch.randint(0, 1000, size=(batch_size,)).to(torch_device) + @property + def main_input_name(self) -> str: + return "hidden_states" - return { - "hidden_states": hidden_states, - "encoder_hidden_states": encoder_hidden_states, - "timestep": timestep, - "encoder_attention_mask": encoder_attention_mask, - } + @property + def model_split_percents(self) -> list: + return [0.7, 0.6, 0.6] @property - def input_shape(self): + def output_shape(self) -> tuple: return (4, 2, 16, 16) @property - def output_shape(self): + def input_shape(self) -> tuple: return (4, 2, 16, 16) - def prepare_init_args_and_inputs_for_common(self): - init_dict = { + @property + def generator(self): + return torch.Generator("cpu").manual_seed(0) + + def get_init_dict(self) -> dict: + return { "patch_size": 2, "num_attention_heads": 2, "attention_head_dim": 8, @@ -78,9 +70,36 @@ def prepare_init_args_and_inputs_for_common(self): "activation_fn": "swiglu", "max_sequence_length": 16, } - inputs_dict = self.dummy_input - return init_dict, inputs_dict + def get_dummy_inputs(self, batch_size: int = 2) -> dict[str, torch.Tensor]: + num_channels = 4 + num_frames = 2 + height = 16 + width = 16 + embedding_dim = 16 + sequence_length = 16 + + return { + "hidden_states": randn_tensor( + (batch_size, num_channels, num_frames, height, width), generator=self.generator, device=torch_device + ), + "encoder_hidden_states": randn_tensor( + (batch_size, sequence_length, embedding_dim), generator=self.generator, device=torch_device + ), + "timestep": torch.randint(0, 1000, size=(batch_size,), generator=self.generator).to(torch_device), + "encoder_attention_mask": torch.ones((batch_size, sequence_length), dtype=torch.bool).to(torch_device), + } + + +class TestMochiTransformer(MochiTransformerTesterConfig, ModelTesterMixin): + pass + + +class TestMochiTransformerTraining(MochiTransformerTesterConfig, TrainingTesterMixin): def test_gradient_checkpointing_is_applied(self): expected_set = {"MochiTransformer3DModel"} super().test_gradient_checkpointing_is_applied(expected_set=expected_set) + + +class TestMochiTransformerCompile(MochiTransformerTesterConfig, TorchCompileTesterMixin): + pass diff --git a/tests/models/transformers/test_models_transformer_omnigen.py b/tests/models/transformers/test_models_transformer_omnigen.py index f1963ddb7709..bd6d846b43cc 100644 --- a/tests/models/transformers/test_models_transformer_omnigen.py +++ b/tests/models/transformers/test_models_transformer_omnigen.py @@ -13,63 +13,50 @@ # See the License for the specific language governing permissions and # limitations under the License. -import unittest - import torch from diffusers import OmniGenTransformer2DModel +from diffusers.utils.torch_utils import randn_tensor from ...testing_utils import enable_full_determinism, torch_device -from ..test_modeling_common import ModelTesterMixin +from ..testing_utils import ( + BaseModelTesterConfig, + ModelTesterMixin, + TorchCompileTesterMixin, + TrainingTesterMixin, +) enable_full_determinism() -class OmniGenTransformerTests(ModelTesterMixin, unittest.TestCase): - model_class = OmniGenTransformer2DModel - main_input_name = "hidden_states" - uses_custom_attn_processor = True - model_split_percents = [0.1, 0.1, 0.1] - +class OmniGenTransformerTesterConfig(BaseModelTesterConfig): @property - def dummy_input(self): - batch_size = 2 - num_channels = 4 - height = 8 - width = 8 - sequence_length = 24 + def model_class(self): + return OmniGenTransformer2DModel - hidden_states = torch.randn((batch_size, num_channels, height, width)).to(torch_device) - timestep = torch.rand(size=(batch_size,), dtype=hidden_states.dtype).to(torch_device) - input_ids = torch.randint(0, 10, (batch_size, sequence_length)).to(torch_device) - input_img_latents = [torch.randn((1, num_channels, height, width)).to(torch_device)] - input_image_sizes = {0: [[0, 0 + height * width // 2 // 2]]} - - attn_seq_length = sequence_length + 1 + height * width // 2 // 2 - attention_mask = torch.ones((batch_size, attn_seq_length, attn_seq_length)).to(torch_device) - position_ids = torch.LongTensor([list(range(attn_seq_length))] * batch_size).to(torch_device) + @property + def main_input_name(self) -> str: + return "hidden_states" - return { - "hidden_states": hidden_states, - "timestep": timestep, - "input_ids": input_ids, - "input_img_latents": input_img_latents, - "input_image_sizes": input_image_sizes, - "attention_mask": attention_mask, - "position_ids": position_ids, - } + @property + def model_split_percents(self) -> list: + return [0.1, 0.1, 0.1] @property - def input_shape(self): + def output_shape(self) -> tuple: return (4, 8, 8) @property - def output_shape(self): + def input_shape(self) -> tuple: return (4, 8, 8) - def prepare_init_args_and_inputs_for_common(self): - init_dict = { + @property + def generator(self): + return torch.Generator("cpu").manual_seed(0) + + def get_init_dict(self) -> dict: + return { "hidden_size": 16, "num_attention_heads": 4, "num_key_value_heads": 4, @@ -81,9 +68,42 @@ def prepare_init_args_and_inputs_for_common(self): "time_step_dim": 4, "rope_scaling": {"long_factor": list(range(1, 3)), "short_factor": list(range(1, 3))}, } - inputs_dict = self.dummy_input - return init_dict, inputs_dict + def get_dummy_inputs(self, batch_size: int = 2) -> dict[str, torch.Tensor]: + num_channels = 4 + height = 8 + width = 8 + sequence_length = 24 + + hidden_states = randn_tensor( + (batch_size, num_channels, height, width), generator=self.generator, device=torch_device + ) + attn_seq_length = sequence_length + 1 + height * width // 2 // 2 + + return { + "hidden_states": hidden_states, + "timestep": torch.rand(size=(batch_size,), generator=self.generator).to(torch_device), + "input_ids": torch.randint(0, 10, (batch_size, sequence_length), generator=self.generator).to( + torch_device + ), + "input_img_latents": [ + randn_tensor((1, num_channels, height, width), generator=self.generator, device=torch_device) + ], + "input_image_sizes": {0: [[0, 0 + height * width // 2 // 2]]}, + "attention_mask": torch.ones((batch_size, attn_seq_length, attn_seq_length)).to(torch_device), + "position_ids": torch.LongTensor([list(range(attn_seq_length))] * batch_size).to(torch_device), + } + + +class TestOmniGenTransformer(OmniGenTransformerTesterConfig, ModelTesterMixin): + pass + + +class TestOmniGenTransformerTraining(OmniGenTransformerTesterConfig, TrainingTesterMixin): def test_gradient_checkpointing_is_applied(self): expected_set = {"OmniGenTransformer2DModel"} super().test_gradient_checkpointing_is_applied(expected_set=expected_set) + + +class TestOmniGenTransformerCompile(OmniGenTransformerTesterConfig, TorchCompileTesterMixin): + pass diff --git a/tests/models/transformers/test_models_transformer_skyreels_v2.py b/tests/models/transformers/test_models_transformer_skyreels_v2.py index 8c36d8256ee9..c5f907fca847 100644 --- a/tests/models/transformers/test_models_transformer_skyreels_v2.py +++ b/tests/models/transformers/test_models_transformer_skyreels_v2.py @@ -12,57 +12,46 @@ # See the License for the specific language governing permissions and # limitations under the License. -import unittest - import torch from diffusers import SkyReelsV2Transformer3DModel +from diffusers.utils.torch_utils import randn_tensor -from ...testing_utils import ( - enable_full_determinism, - torch_device, +from ...testing_utils import enable_full_determinism, torch_device +from ..testing_utils import ( + BaseModelTesterConfig, + ModelTesterMixin, + TorchCompileTesterMixin, + TrainingTesterMixin, ) -from ..test_modeling_common import ModelTesterMixin, TorchCompileTesterMixin enable_full_determinism() -class SkyReelsV2Transformer3DTests(ModelTesterMixin, TorchCompileTesterMixin, unittest.TestCase): - model_class = SkyReelsV2Transformer3DModel - main_input_name = "hidden_states" - uses_custom_attn_processor = True - +class SkyReelsV2TransformerTesterConfig(BaseModelTesterConfig): @property - def dummy_input(self): - batch_size = 1 - num_channels = 4 - num_frames = 2 - height = 16 - width = 16 - text_encoder_embedding_dim = 16 - sequence_length = 12 + def model_class(self): + return SkyReelsV2Transformer3DModel - hidden_states = torch.randn((batch_size, num_channels, num_frames, height, width)).to(torch_device) - timestep = torch.randint(0, 1000, size=(batch_size,)).to(torch_device) - encoder_hidden_states = torch.randn((batch_size, sequence_length, text_encoder_embedding_dim)).to(torch_device) - - return { - "hidden_states": hidden_states, - "encoder_hidden_states": encoder_hidden_states, - "timestep": timestep, - } + @property + def main_input_name(self) -> str: + return "hidden_states" @property - def input_shape(self): + def output_shape(self) -> tuple: return (4, 1, 16, 16) @property - def output_shape(self): + def input_shape(self) -> tuple: return (4, 1, 16, 16) - def prepare_init_args_and_inputs_for_common(self): - init_dict = { + @property + def generator(self): + return torch.Generator("cpu").manual_seed(0) + + def get_init_dict(self) -> dict: + return { "patch_size": (1, 2, 2), "num_attention_heads": 2, "attention_head_dim": 12, @@ -76,9 +65,37 @@ def prepare_init_args_and_inputs_for_common(self): "qk_norm": "rms_norm_across_heads", "rope_max_seq_len": 32, } - inputs_dict = self.dummy_input - return init_dict, inputs_dict + def get_dummy_inputs(self, batch_size: int = 1) -> dict[str, torch.Tensor]: + num_channels = 4 + num_frames = 2 + height = 16 + width = 16 + text_encoder_embedding_dim = 16 + sequence_length = 12 + + return { + "hidden_states": randn_tensor( + (batch_size, num_channels, num_frames, height, width), generator=self.generator, device=torch_device + ), + "encoder_hidden_states": randn_tensor( + (batch_size, sequence_length, text_encoder_embedding_dim), + generator=self.generator, + device=torch_device, + ), + "timestep": torch.randint(0, 1000, size=(batch_size,), generator=self.generator).to(torch_device), + } + + +class TestSkyReelsV2Transformer(SkyReelsV2TransformerTesterConfig, ModelTesterMixin): + pass + + +class TestSkyReelsV2TransformerTraining(SkyReelsV2TransformerTesterConfig, TrainingTesterMixin): def test_gradient_checkpointing_is_applied(self): expected_set = {"SkyReelsV2Transformer3DModel"} super().test_gradient_checkpointing_is_applied(expected_set=expected_set) + + +class TestSkyReelsV2TransformerCompile(SkyReelsV2TransformerTesterConfig, TorchCompileTesterMixin): + pass From 7004c37deda8779ca2402aa3c1802aa822e3fc7d Mon Sep 17 00:00:00 2001 From: DN6 Date: Tue, 14 Apr 2026 15:45:55 +0530 Subject: [PATCH 2/2] update --- .../test_models_transformer_hunyuan_video.py | 30 +------------------ .../test_models_transformer_lumina.py | 5 ---- .../test_models_transformer_lumina2.py | 5 ---- .../test_models_transformer_mochi.py | 5 ---- .../test_models_transformer_omnigen.py | 5 ---- .../test_models_transformer_skyreels_v2.py | 5 ---- 6 files changed, 1 insertion(+), 54 deletions(-) diff --git a/tests/models/transformers/test_models_transformer_hunyuan_video.py b/tests/models/transformers/test_models_transformer_hunyuan_video.py index 385a5eefd58b..04810fd8cfe9 100644 --- a/tests/models/transformers/test_models_transformer_hunyuan_video.py +++ b/tests/models/transformers/test_models_transformer_hunyuan_video.py @@ -22,7 +22,7 @@ enable_full_determinism, torch_device, ) -from ..test_modeling_common import ModelTesterMixin, TorchCompileTesterMixin +from ..test_modeling_common import ModelTesterMixin enable_full_determinism() @@ -93,13 +93,6 @@ def test_gradient_checkpointing_is_applied(self): super().test_gradient_checkpointing_is_applied(expected_set=expected_set) -class HunyuanTransformerCompileTests(TorchCompileTesterMixin, unittest.TestCase): - model_class = HunyuanVideoTransformer3DModel - - def prepare_init_args_and_inputs_for_common(self): - return HunyuanVideoTransformer3DTests().prepare_init_args_and_inputs_for_common() - - class HunyuanSkyreelsImageToVideoTransformer3DTests(ModelTesterMixin, unittest.TestCase): model_class = HunyuanVideoTransformer3DModel main_input_name = "hidden_states" @@ -168,13 +161,6 @@ def test_gradient_checkpointing_is_applied(self): super().test_gradient_checkpointing_is_applied(expected_set=expected_set) -class HunyuanSkyreelsImageToVideoCompileTests(TorchCompileTesterMixin, unittest.TestCase): - model_class = HunyuanVideoTransformer3DModel - - def prepare_init_args_and_inputs_for_common(self): - return HunyuanSkyreelsImageToVideoTransformer3DTests().prepare_init_args_and_inputs_for_common() - - class HunyuanVideoImageToVideoTransformer3DTests(ModelTesterMixin, unittest.TestCase): model_class = HunyuanVideoTransformer3DModel main_input_name = "hidden_states" @@ -241,13 +227,6 @@ def test_gradient_checkpointing_is_applied(self): super().test_gradient_checkpointing_is_applied(expected_set=expected_set) -class HunyuanImageToVideoCompileTests(TorchCompileTesterMixin, unittest.TestCase): - model_class = HunyuanVideoTransformer3DModel - - def prepare_init_args_and_inputs_for_common(self): - return HunyuanVideoImageToVideoTransformer3DTests().prepare_init_args_and_inputs_for_common() - - class HunyuanVideoTokenReplaceImageToVideoTransformer3DTests(ModelTesterMixin, unittest.TestCase): model_class = HunyuanVideoTransformer3DModel main_input_name = "hidden_states" @@ -314,10 +293,3 @@ def test_output(self): def test_gradient_checkpointing_is_applied(self): expected_set = {"HunyuanVideoTransformer3DModel"} super().test_gradient_checkpointing_is_applied(expected_set=expected_set) - - -class HunyuanVideoTokenReplaceCompileTests(TorchCompileTesterMixin, unittest.TestCase): - model_class = HunyuanVideoTransformer3DModel - - def prepare_init_args_and_inputs_for_common(self): - return HunyuanVideoTokenReplaceImageToVideoTransformer3DTests().prepare_init_args_and_inputs_for_common() diff --git a/tests/models/transformers/test_models_transformer_lumina.py b/tests/models/transformers/test_models_transformer_lumina.py index e68a06fbb77d..6c6403727288 100644 --- a/tests/models/transformers/test_models_transformer_lumina.py +++ b/tests/models/transformers/test_models_transformer_lumina.py @@ -22,7 +22,6 @@ from ..testing_utils import ( BaseModelTesterConfig, ModelTesterMixin, - TorchCompileTesterMixin, TrainingTesterMixin, ) @@ -95,7 +94,3 @@ class TestLuminaNextDiT(LuminaNextDiTTesterConfig, ModelTesterMixin): class TestLuminaNextDiTTraining(LuminaNextDiTTesterConfig, TrainingTesterMixin): pass - - -class TestLuminaNextDiTCompile(LuminaNextDiTTesterConfig, TorchCompileTesterMixin): - pass diff --git a/tests/models/transformers/test_models_transformer_lumina2.py b/tests/models/transformers/test_models_transformer_lumina2.py index ea1b52631ba8..4fdd81b8762d 100644 --- a/tests/models/transformers/test_models_transformer_lumina2.py +++ b/tests/models/transformers/test_models_transformer_lumina2.py @@ -22,7 +22,6 @@ from ..testing_utils import ( BaseModelTesterConfig, ModelTesterMixin, - TorchCompileTesterMixin, TrainingTesterMixin, ) @@ -96,7 +95,3 @@ class TestLumina2TransformerTraining(Lumina2TransformerTesterConfig, TrainingTes def test_gradient_checkpointing_is_applied(self): expected_set = {"Lumina2Transformer2DModel"} super().test_gradient_checkpointing_is_applied(expected_set=expected_set) - - -class TestLumina2TransformerCompile(Lumina2TransformerTesterConfig, TorchCompileTesterMixin): - pass diff --git a/tests/models/transformers/test_models_transformer_mochi.py b/tests/models/transformers/test_models_transformer_mochi.py index fe6ea8be5533..992df7cf6905 100644 --- a/tests/models/transformers/test_models_transformer_mochi.py +++ b/tests/models/transformers/test_models_transformer_mochi.py @@ -22,7 +22,6 @@ from ..testing_utils import ( BaseModelTesterConfig, ModelTesterMixin, - TorchCompileTesterMixin, TrainingTesterMixin, ) @@ -99,7 +98,3 @@ class TestMochiTransformerTraining(MochiTransformerTesterConfig, TrainingTesterM def test_gradient_checkpointing_is_applied(self): expected_set = {"MochiTransformer3DModel"} super().test_gradient_checkpointing_is_applied(expected_set=expected_set) - - -class TestMochiTransformerCompile(MochiTransformerTesterConfig, TorchCompileTesterMixin): - pass diff --git a/tests/models/transformers/test_models_transformer_omnigen.py b/tests/models/transformers/test_models_transformer_omnigen.py index bd6d846b43cc..60d4bac84bd2 100644 --- a/tests/models/transformers/test_models_transformer_omnigen.py +++ b/tests/models/transformers/test_models_transformer_omnigen.py @@ -22,7 +22,6 @@ from ..testing_utils import ( BaseModelTesterConfig, ModelTesterMixin, - TorchCompileTesterMixin, TrainingTesterMixin, ) @@ -103,7 +102,3 @@ class TestOmniGenTransformerTraining(OmniGenTransformerTesterConfig, TrainingTes def test_gradient_checkpointing_is_applied(self): expected_set = {"OmniGenTransformer2DModel"} super().test_gradient_checkpointing_is_applied(expected_set=expected_set) - - -class TestOmniGenTransformerCompile(OmniGenTransformerTesterConfig, TorchCompileTesterMixin): - pass diff --git a/tests/models/transformers/test_models_transformer_skyreels_v2.py b/tests/models/transformers/test_models_transformer_skyreels_v2.py index c5f907fca847..96a43d6f8209 100644 --- a/tests/models/transformers/test_models_transformer_skyreels_v2.py +++ b/tests/models/transformers/test_models_transformer_skyreels_v2.py @@ -21,7 +21,6 @@ from ..testing_utils import ( BaseModelTesterConfig, ModelTesterMixin, - TorchCompileTesterMixin, TrainingTesterMixin, ) @@ -95,7 +94,3 @@ class TestSkyReelsV2TransformerTraining(SkyReelsV2TransformerTesterConfig, Train def test_gradient_checkpointing_is_applied(self): expected_set = {"SkyReelsV2Transformer3DModel"} super().test_gradient_checkpointing_is_applied(expected_set=expected_set) - - -class TestSkyReelsV2TransformerCompile(SkyReelsV2TransformerTesterConfig, TorchCompileTesterMixin): - pass