AttributeError: 'list' object has no attribute '__module__'. #7866
-
Bug DescriptionI planned to design a class that inherits DDIMPipeline and tracks the intermiate images, so I rewrtite the init() function as follows: class LocalDDIMPipeline(DDIMPipeline):
def __init__(self, unet, scheduler, extract_time):
super().__init__(unet, scheduler)
self.scheduler_forward = DDIMInverseScheduler.from_config(scheduler.config)
if isinstance(extract_time, list):
self.extract_time_list = extract_time
self.extract_time_count = len(extract_time)
else:
raise TypeError(f"The type of extract_time is not a List")
self.register_modules(unet=unet, scheduler=scheduler, extract_time=extract_time)However, when I run the following code, pipeline = LocalDDIMPipeline(
unet = model,
scheduler = DDIMScheduler.from_pretrained(args.save_path, subfolder="scheduler"),
extract_time=[100],
)and the terminal raised this error: Traceback (most recent call last):
File "/media/data3/wengzh/CodeRef/Pruning-Influence-via-Hardness/ddpm_prune.py", line 143, in <module>
pipeline = LocalDDIMPipeline(
File "/media/data3/wengzh/CodeRef/Pruning-Influence-via-Hardness/Local_ddim_pipeline.py", line 20, in __init__
self.register_modules(unet=unet, scheduler=scheduler, extract_time=extract_time)
File "/media/data3/wengzh/CodeRef/Pruning-Influence-via-Hardness/diffusers/pipelines/pipeline_utils.py", line 485, in register_modules
library = module.__module__.split(".")[0]
AttributeError: 'list' object has no attribute '__module__'. Did you mean: '__mul__'?The function register_modules() is as follows: def register_modules(self, **kwargs):
for name, module in kwargs.items():
# retrieve library
if module is None or isinstance(module, (tuple, list)) and module[0] is None:
register_dict = {name: (None, None)}
else:
library, class_name = _fetch_class_library_tuple(module)
register_dict = {name: (library, class_name)}
# save model index config
self.register_to_config(**register_dict)
# set models
setattr(self, name, module)This code could be found in pipeline_utils.py in diffusers |
Beta Was this translation helpful? Give feedback.
Replies: 2 comments 8 replies
-
|
Have you examined the callbacks page in the docs to be able to do this? |
Beta Was this translation helpful? Give feedback.
-
|
Sorry, I haven't examined this before. |
Beta Was this translation helpful? Give feedback.
-
|
I read this instruction. It seems like the callback is not available in DDIMPipeline and DDPMPipeline. |
Beta Was this translation helpful? Give feedback.
-
|
I have just noticed/remembered that |
Beta Was this translation helpful? Give feedback.
-
|
Actually, my purpose is to use the intermediate images at preset timestep to do one-step denoising(using the DDIMSchduler) and reverse(using the DDIMInverseScheduler). Hence, I would like to inherits DDIMPipeline and implement the one-step denoising and reverse in the call() function of a new pipeline(I call it LocalDDIMPipeline)and save the selected images. If I save those image variables after postprocessing, it will be a little bit troublesome. Or is there any other approaches that can jump out of my thinking? The code of LocalDDIMPipeline is as follows: class LocalDDIMPipeline(DDIMPipeline):
def __init__(self, unet, scheduler, extract_time):
super().__init__(unet, scheduler)
self.scheduler_forward = DDIMInverseScheduler.from_config(scheduler.config)
if isinstance(extract_time, list):
self.extract_time_list = extract_time
self.extract_time_count = len(extract_time)
else:
raise TypeError(f"The type of extract_time is not a List")
self.register_modules(unet=unet, scheduler=scheduler, extract_time=extract_time)
@torch.no_grad()
def __call__(self,
batch_size: int = 1,
generator = None, eta: float = 0,
num_inference_steps: int = 50,
use_clipped_model_output: bool | None = None,
output_type: str | None = "pil",
return_dict: bool = True
):
r"""
The call function to the pipeline for generation.
Args:
batch_size (`int`, *optional*, defaults to 1):
The number of images to generate.
generator (`torch.Generator`, *optional*):
A [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) to make
generation deterministic.
eta (`float`, *optional*, defaults to 0.0):
Corresponds to parameter eta (η) from the [DDIM](https://arxiv.org/abs/2010.02502) paper. Only applies
to the [`~schedulers.DDIMScheduler`], and is ignored in other schedulers. A value of `0` corresponds to
DDIM and `1` corresponds to DDPM.
num_inference_steps (`int`, *optional*, defaults to 50):
The number of denoising steps. More denoising steps usually lead to a higher quality image at the
expense of slower inference.
use_clipped_model_output (`bool`, *optional*, defaults to `None`):
If `True` or `False`, see documentation for [`DDIMScheduler.step`]. If `None`, nothing is passed
downstream to the scheduler (use `None` for schedulers which don't support this argument).
output_type (`str`, *optional*, defaults to `"pil"`):
The output format of the generated image. Choose between `PIL.Image` or `np.array`.
return_dict (`bool`, *optional*, defaults to `True`):
Whether or not to return a [`~pipelines.ImagePipelineOutput`] instead of a plain tuple.
Example:
```py
>>> from diffusers import DDIMPipeline
>>> import PIL.Image
>>> import numpy as np
>>> # load model and scheduler
>>> pipe = DDIMPipeline.from_pretrained("fusing/ddim-lsun-bedroom")
>>> # run pipeline in inference (sample random noise and denoise)
>>> image = pipe(eta=0.0, num_inference_steps=50)
>>> # process image to PIL
>>> image_processed = image.cpu().permute(0, 2, 3, 1)
>>> image_processed = (image_processed + 1.0) * 127.5
>>> image_processed = image_processed.numpy().astype(np.uint8)
>>> image_pil = PIL.Image.fromarray(image_processed[0])
>>> # save image
>>> image_pil.save("test.png")
```
Returns:
[`~pipelines.ImagePipelineOutput`] or `tuple`:
If `return_dict` is `True`, [`~pipelines.ImagePipelineOutput`] is returned, otherwise a `tuple` is
returned where the first element is a list with the generated images
"""
# Sample gaussian noise to begin loop
if isinstance(self.unet.config.sample_size, int):
image_shape = (
batch_size,
self.unet.config.in_channels,
self.unet.config.sample_size,
self.unet.config.sample_size,
)
else:
image_shape = (batch_size, self.unet.config.in_channels, *self.unet.config.sample_size)
if isinstance(generator, list) and len(generator) != batch_size:
raise ValueError(
f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
f" size of {batch_size}. Make sure the batch size matches the length of the generators."
)
image = randn_tensor(image_shape, generator=generator, device=self._execution_device, dtype=self.unet.dtype)
image_set = []
# set step values
self.scheduler.set_timesteps(num_inference_steps)
self.scheduler_forward.set_timesteps(num_inference_steps)
for t in self.progress_bar(self.scheduler.timesteps):
# 1. predict noise model_output
model_output = self.unet(image, t).sample
# 2. predict previous mean of image x_t-1 and add variance depending on eta
# eta corresponds to η in paper and should be between [0, 1]
# do x_t -> x_t-1
# extract the intermediate images according to the time-step
image = self.scheduler.step(
model_output, t, image, eta=eta, use_clipped_model_output=use_clipped_model_output, generator=generator
).prev_sample
if t in self.extract_time_list:
# compute the one-step denoising
model_output_denoise = self.unet(image, t+1).sample
image_denoise = self.scheduler.step(
model_output_denoise, t+1, image, eta=eta, use_clipped_model_output=use_clipped_model_output, generator=generator
).prev_sample
# compute the one-step forward
image_forward = self.scheduler_forward.step(
model_output_denoise, t+1, image_denoise, eta=eta, use_clipped_model_output=use_clipped_model_output, generator=generator
).prev_sample
# store the original denoising image and one-step denoise and forward
image_temp = (image / 2 + 0.5).clamp(0, 1)
image_temp = image_temp.cpu().permute(0, 2, 3, 1).numpy()
if output_type == "pil":
image_temp = self.numpy_to_pil(image_temp)
image_set.append(image_temp)
image_onestep = (image_forward / 2 + 0.5).clamp(0, 1)
image_onestep = image_onestep.cpu().permute(0, 2, 3, 1).numpy()
if output_type == "pil":
image_onestep = self.numpy_to_pil(image_onestep)
image_set.append(image_onestep)
image = (image / 2 + 0.5).clamp(0, 1)
image = image.cpu().permute(0, 2, 3, 1).numpy()
if output_type == "pil":
image = self.numpy_to_pil(image)
image_set.append(image)
if not return_dict:
return (image_set,)
return ImagePipelineOutput(images=image_set)
# return super().__call__(batch_size, generator, eta, num_inference_steps, use_clipped_model_output, output_type, return_dict) |
Beta Was this translation helpful? Give feedback.
-
|
IMO the error is pretty much self explanatory, but I'm more curious in what version of
in the actual code it's an empty line: Also, this Anyway, why are you registering |
Beta Was this translation helpful? Give feedback.
-
|
Because if I do not register Traceback (most recent call last):
File "/media/data3/wengzh/CodeRef/Pruning-Influence-via-Hardness/ddpm_prune.py", line 150, in <module>
pipeline.to("cuda")
File "/media/data3/wengzh/CodeRef/Pruning-Influence-via-Hardness/diffusers/pipelines/pipeline_utils.py", line 637, in to
module_is_sequentially_offloaded(module) for _, module in self.components.items()
File "/media/data3/wengzh/CodeRef/Pruning-Influence-via-Hardness/diffusers/pipelines/pipeline_utils.py", line 1385, in components
raise ValueError(
ValueError: LocalDDIMPipeline {
"_class_name": "LocalDDIMPipeline",
"_diffusers_version": "0.17.0.dev0",
"scheduler": [
"diffusers",
"DDIMScheduler"
],
"unet": [
"diffusers",
"UNet2DModel"
]
}
has been incorrectly initialized or <class 'Local_ddim_pipeline.LocalDDIMPipeline'> is incorrectly implemented. Expected {'scheduler', 'extract_time', 'unet'} to be defined, but dict_keys(['unet', 'scheduler']) are defined.Therefore, I try to fix by registering ``self.extract_time_list```. Is it inappropriate to do this? |
Beta Was this translation helpful? Give feedback.
-
|
The version of |
Beta Was this translation helpful? Give feedback.
-
|
yeah, more than inappropriate, is that all the args of the So don't use the Also better to load the pipeline with So for example: pipeline = LocalDDIMPipeline.from_pretrained("path_to_model", scheduler=your_scheduler)If you're using the scheduler that's with the model, you don't need to provide the scheduler. |
Beta Was this translation helpful? Give feedback.
-
|
OK, now I've understand what you mean. Thanks for your precious time! |
Beta Was this translation helpful? Give feedback.
yeah, more than inappropriate, is that all the args of the
__init__are processed as modules when you inherit from a pipeline.So don't use the
__init__to set variables that you need, do this in the__call__method, you can learn from examples in the community pipelines, like this one.Also better to load the pipeline with
from_pretrainedinstead, that way you get all the additional features thatdiffusersgives if you need them.So for example:
If you're using the scheduler that's with the model, you don't need to provide the scheduler.