Method forward

diffsynth/models/sd_unet.py:148–208

(
        self,
        hidden_states, time_emb, text_emb, res_stack,
        cross_frame_attention=False,
        tiled=False, tile_size=64, tile_stride=32,
        ipadapter_kwargs_list={},
        **kwargs
    )

            self.proj_out = torch.nn.Linear(inner_dim, in_channels)

    def forward(
        self,
        hidden_states, time_emb, text_emb, res_stack,
        cross_frame_attention=False,
        tiled=False, tile_size=64, tile_stride=32,
        ipadapter_kwargs_list={},
        **kwargs
    ):
        batch, _, height, width = hidden_states.shape
        residual = hidden_states

        hidden_states = self.norm(hidden_states)
        inner_dim = hidden_states.shape[1]
        hidden_states = hidden_states.permute(0, 2, 3, 1).reshape(batch, height * width, inner_dim)
        hidden_states = self.proj_in(hidden_states)

        if cross_frame_attention:
            hidden_states = hidden_states.reshape(1, batch * height * width, inner_dim)
            encoder_hidden_states = text_emb.mean(dim=0, keepdim=True)
        else:
            encoder_hidden_states = text_emb
            if encoder_hidden_states.shape[0] != hidden_states.shape[0]:
                encoder_hidden_states = encoder_hidden_states.repeat(hidden_states.shape[0], 1, 1)

        if tiled:
            tile_size = min(tile_size, min(height, width))
            hidden_states = hidden_states.permute(0, 2, 1).reshape(batch, inner_dim, height, width)
            def block_tile_forward(x):
                b, c, h, w = x.shape
                x = x.permute(0, 2, 3, 1).reshape(b, h*w, c)
                x = block(x, encoder_hidden_states)
                x = x.reshape(b, h, w, c).permute(0, 3, 1, 2)
                return x
            for block in self.transformer_blocks:
                hidden_states = TileWorker().tiled_forward(
                    block_tile_forward,
                    hidden_states,
                    tile_size,
                    tile_stride,
                    tile_device=hidden_states.device,
                    tile_dtype=hidden_states.dtype
                )
            hidden_states = hidden_states.permute(0, 2, 3, 1).reshape(batch, height * width, inner_dim)
        else:
            for block_id, block in enumerate(self.transformer_blocks):
                hidden_states = block(
                    hidden_states,
                    encoder_hidden_states=encoder_hidden_states,
                    ipadapter_kwargs=ipadapter_kwargs_list.get(block_id, None)
                )
        if cross_frame_attention:
            hidden_states = hidden_states.reshape(batch, height * width, inner_dim)

        if self.need_proj_out:
            hidden_states = self.proj_out(hidden_states)
            hidden_states = hidden_states.reshape(batch, height, width, inner_dim).permute(0, 3, 1, 2).contiguous()
            hidden_states = hidden_states + residual
        else: