daam package

Subpackages

• daam.run package
  • Submodules
  • daam.run.annotate module
  • daam.run.daam_to_mask module
  • daam.run.evaluate module
  • daam.run.filter_coco module
  • daam.run.generate module
  • daam.run.test_literacy module
  • daam.run.test_numeracy module
  • Module contents

Submodules

daam.evaluate module

class daam.evaluate.MeanEvaluator(name: str = 'MeanEvaluator')

Bases: object

log_intensity(pred: torch.Tensor)

log_iou(preds: Union[torch.Tensor, List[torch.Tensor]], truth: torch.Tensor)

property mean_intensity: float

property mean_iou: float

daam.evaluate.compute_iou(a: torch.Tensor, b: torch.Tensor) → float

daam.experiment module

class daam.experiment.GenerationExperiment(id: str, image: PIL.Image.Image, global_heat_map: torch.Tensor, seed: int, prompt: str, path: Optional[pathlib.Path] = None, truth_masks: Optional[Dict[str, torch.Tensor]] = None, prediction_masks: Optional[Dict[str, torch.Tensor]] = None, annotations: Optional[Dict[str, Any]] = None)

Bases: object

Class to hold experiment parameters. Pickleable.

annotate(key: str, value: Any) → daam.experiment.GenerationExperiment

annotations: Optional[Dict[str, Any]] = None

clear_prediction_masks(name: str)

static contains_truth_mask(path: str | pathlib.Path, prompt_id: Optional[str] = None) → bool

global_heat_map: torch.Tensor

static has_annotations(path: str | pathlib.Path) → bool

static has_experiment(path: str | pathlib.Path, prompt_id: str) → bool

id: str

image: PIL.Image.Image

classmethod load(path: str, pred_prefix: str = 'daam', composite: bool = False, simplify80: bool = False, vocab: Optional[List[str]] = None) → daam.experiment.GenerationExperiment

nsfw() → bool

path: Optional[pathlib.Path] = None

prediction_masks: Optional[Dict[str, torch.Tensor]] = None

prompt: str

static read_prompt(path: str | pathlib.Path, prompt_id: Optional[str] = None) → str

static read_seed(path: str | pathlib.Path, prompt_id: Optional[str] = None) → int

save(path: Optional[str] = None)

save_annotations(path: Optional[pathlib.Path] = None)

save_heat_map(tokenizer: transformers.tokenization_utils.PreTrainedTokenizer, word: str)

save_prediction_mask(mask: torch.Tensor, word: str, name: str)

seed: int

truth_masks: Optional[Dict[str, torch.Tensor]] = None

daam.experiment.build_word_list_coco80() → Dict[str, List[str]]

daam.hook module

class daam.hook.AggregateHooker(module: daam.hook.ModuleType)

Bases: daam.hook.ObjectHooker[daam.hook.ModuleListType]

register_hook(hook: daam.hook.ObjectHooker)

class daam.hook.ModuleLocator

Bases: Generic[daam.hook.ModuleType]

locate(model: torch.nn.modules.module.Module) → List[daam.hook.ModuleType]

class daam.hook.ObjectHooker(module: daam.hook.ModuleType)

Bases: Generic[daam.hook.ModuleType]

hook()

monkey_patch(fn_name, fn)

monkey_super(fn_name, *args, **kwargs)

unhook()

class daam.hook.UNetCrossAttentionLocator

Bases: daam.hook.ModuleLocator[diffusers.models.attention.CrossAttention]

locate(model: diffusers.models.unet_2d_condition.UNet2DConditionModel) → List[diffusers.models.attention.CrossAttention]

Locate all cross-attention modules in a UNet2DConditionModel.

Parameters

model (UNet2DConditionModel) – The model to locate the cross-attention modules in.

Returns

The list of cross-attention modules.

Return type

List[CrossAttention]

daam.trace module

class daam.trace.DiffusionHeatMapHooker(pipeline: diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline, weighted: bool = False)

Bases: daam.hook.AggregateHooker

property all_heat_maps

compute_global_heat_map(prompt: str, time_weights: Optional[List[float]] = None, time_idx: Optional[int] = None, last_n: Optional[int] = None, factors: Optional[List[float]] = None) → daam.trace.HeatMap

Compute the global heat map for the given prompt, aggregating across time (inference steps) and space (different spatial transformer block heat maps).

Parameters

• prompt – The prompt to compute the heat map for.

• time_weights – The weights to apply to each time step. If None, all time steps are weighted equally.

• time_idx – The time step to compute the heat map for. If None, the heat map is computed for all time steps.

• last_n – The number of time steps (last n) to use. If None, the heat map is computed for all time steps.

• factors – Restrict the application to heat maps with spatial factors in this set. If None, use all sizes.

class daam.trace.HeatMap(tokenizer: Any, prompt: str, heat_maps: torch.Tensor)

Bases: object

compute_word_heat_map(word: str, word_idx: Optional[int] = None) → torch.Tensor

class daam.trace.MmDetectHeatMap(pred_file: str | pathlib.Path, threshold: float = 0.95)

Bases: object

compute_word_heat_map(word: str) → torch.Tensor

daam.trace.trace

alias of daam.trace.DiffusionHeatMapHooker

daam.utils module

daam.utils.compute_token_merge_indices(tokenizer, prompt: str, word: str, word_idx: Optional[int] = None)

daam.utils.expand_image(im: torch.Tensor, out: int = 512, absolute: bool = False, threshold: Optional[float] = None) → torch.Tensor

daam.utils.plot_mask_heat_map(im: PIL.Image.Image, heat_map: torch.Tensor, threshold: float = 0.4)

daam.utils.plot_overlay_heat_map(im: PIL.Image.Image | numpy.ndarray, heat_map: torch.Tensor, word: Optional[str] = None, out_file: Optional[pathlib.Path] = None)

daam.utils.set_seed(seed: int) → torch._C.Generator

Module contents