diffusers/main/tr/modular_diffusers/pipeline_block.md

ModülerPipelineBlokları

ModularPipelineBlocks, bir ModularPipeline oluşturmak için temel bloktur. Bir iş akışındaki belirli bir adım için bir bloğun hangi bileşenleri, girdi/çıktıları ve hesaplamaları gerçekleştirmesi gerektiğini tanımlar. ModularPipelineBlocks, state kullanarak diğer bloklarla bağlantı kurar ve iş akışlarının modüler olarak oluşturulmasını sağlar.

Tek başına bir ModularPipelineBlocks çalıştırılamaz. Bir adımın bir pipeline'da ne yapması gerektiğine dair bir taslaktır. Bir pipeline'ı gerçekten çalıştırmak ve yürütmek için ModularPipelineBlocks'ün bir ModularPipeline'a dönüştürülmesi gerekir.

Bu kılavuz, ModularPipelineBlocks oluşturmayı gösterecektir.

Girdiler ve çıktılar

Modular Diffusers'da durumun nasıl çalıştığını bilmiyorsanız, States kılavuzuna başvurun.

ModularPipelineBlocks bir inputs ve intermediate_outputs gerektirir.

• inputs, bir bloğun hesaplama işlemini gerçekleştirmek için PipelineState üzerinden okuduğu değerlerdir. Bunlar, bir kullanıcı tarafından sağlanan değerler (bir istem veya görüntü gibi) ya da önceki bir blok tarafından üretilen değerler (kodlanmış image_latents gibi) olabilir.

  inputs tanımlamak için InputParam kullanın.

class ImageEncodeStep(ModularPipelineBlocks):
    ...

    @property
    def inputs(self):
        return [
            InputParam(name="image", type_hint="PIL.Image", required=True, description="raw input image to process"),
        ]
    ...

• intermediate_outputs, bir blok tarafından oluşturulan ve PipelineState'e eklenen yeni değerlerdir. intermediate_outputs, sonraki bloklar için inputs olarak kullanılabilir veya pipeline'ın çalıştırılmasından elde edilen nihai çıktı olarak kullanılabilir.

  intermediate_outputs tanımlamak için OutputParam kullanın.

class ImageEncodeStep(ModularPipelineBlocks):
    ...

    @property
    def intermediate_outputs(self):
        return [
            OutputParam(name="image_latents", description="latents representing the image"),
        ]

    ...

Ara girdiler ve çıktılar, blokları birbirine bağlamak için verileri paylaşır. Herhangi bir noktada erişilebilir oldukları için iş akışının ilerlemesini izlemenizi sağlarlar.

Bileşenler ve yapılandırmalar

Bir bloğun ihtiyaç duyduğu bileşenler ve pipeline düzeyindeki yapılandırmalar ComponentSpec ve ConfigSpec içinde belirtilir.

• ComponentSpec, bir bloğun kullandığı beklenen bileşenleri içerir. Bileşenin name değerine ve ideal olarak bileşenin tam olarak ne olduğunu belirten bir type_hint değerine ihtiyacınız vardır.
• ConfigSpec, tüm bloklarda davranışı kontrol eden pipeline düzeyinde ayarları içerir.

class ImageEncodeStep(ModularPipelineBlocks):
    ...

    @property
    def expected_components(self):
        return [
            ComponentSpec(name="vae", type_hint=AutoencoderKL),
        ]

    @property
    def expected_configs(self):
        return [
            ConfigSpec("force_zeros_for_empty_prompt", True),
        ]

    ...

Bloklar bir pipeline'a dönüştürüldüğünde, bileşenler __call__'in ilk argümanı olarak bloğa erişilebilir hale gelir.

Hesaplama mantığı

Bir bloğun gerçekleştirdiği hesaplama, __call__ yönteminde tanımlanır ve belirli bir yapıyı izler.

1. inputs için yerel bir görünüm almak üzere BlockState nesnesini alın.
2. inputs üzerinde hesaplama mantığını uygulayın.
3. Yerel BlockState'ten değişiklikleri küresel PipelineState'ye geri göndermek için PipelineState'i güncelleyin.
4. Bir sonraki bloğa erişilebilir hale gelen bileşenleri ve durumu döndürür.

class ImageEncodeStep(ModularPipelineBlocks):

    def __call__(self, components, state):
        # Get a local view of the state variables this block needs
        block_state = self.get_block_state(state)

        # Your computation logic here
        # block_state contains all your inputs
        # Access them like: block_state.image, block_state.processed_image

        # Update the pipeline state with your updated block_states
        self.set_block_state(state, block_state)
        return components, state

Hepsini bir araya getirme

İşte tüm parçalar birleştirilmiş tam blok.

from diffusers import ComponentSpec, AutoencoderKL
from diffusers.modular_pipelines import InputParam, ModularPipelineBlocks, OutputParam

class ImageEncodeStep(ModularPipelineBlocks):

    @property
    def description(self):
        return "Encode an image into latent space."

    @property
    def expected_components(self):
        return [
            ComponentSpec(name="vae", type_hint=AutoencoderKL),
        ]

    @property
    def inputs(self):
        return [
            InputParam(name="image", type_hint="PIL.Image", required=True, description="raw input image to process"),
        ]

    @property
    def intermediate_outputs(self):
        return [
            OutputParam(name="image_latents", type_hint="torch.Tensor", description="latents representing the image"),
        ]

    def __call__(self, components, state):
        block_state = self.get_block_state(state)
        block_state.image_latents = components.vae.encode(block_state.image)
        self.set_block_state(state, block_state)
        return components, state

Her bloğun, yukarıda tanımladığınız özelliklerden otomatik olarak oluşturulan bir doc özelliği vardır. Bu özellik, bloğun açıklamasının, bileşenlerinin, girdilerinin ve çıktılarının bir özetini sunar.

block = ImageEncoderStep()
print(block.doc)
class ImageEncodeStep

  Encode an image into latent space.

  Components:
      vae (`AutoencoderKL`)

  Inputs:
      image (`PIL.Image`):
          raw input image to process

  Outputs:
      image_latents (`torch.Tensor`):
          latents representing the image