ModularPipeline

يحوّل ModularPipeline الكتل ModularPipelineBlocks إلى خط أنابيب قابل للتنفيذ يقوم بتحميل النماذج وتنفيذ خطوات الحساب المعرّفة في تلك الكتل. وهو الواجهة الرئيسية لتشغيل خط الأنابيب، وتتشابه واجهة برمجياته بشكل كبير مع DiffusionPipeline مع وجود بعض الفروقات الجوهرية.

• Loading is lazy. With DiffusionPipeline, from_pretrained() creates the pipeline and loads all models at the same time. With ModularPipeline, creating and loading are two separate steps: from_pretrained() reads the configuration and knows where to load each component from, but doesn’t actually load the model weights. You load the models later with load_components(), which is where you pass loading arguments like dtype and quantization_config.

• طريقتان لإنشاء خط أنابيب. يمكنك استخدام from_pretrained() مع مستودع نموذج diffusers موجود مسبقًا — حيث يقوم تلقائيًا بالربط مع كتل خط الأنابيب الافتراضية ثم التحويل إلى ModularPipeline دون أي إعداد إضافي. يمكنك الاطلاع على modular_pipelines_directory لمعرفة النماذج المدعومة حاليًا. كما يمكنك تجميع خط أنابيب خاص بك من ModularPipelineBlocks وتحويله باستخدام طريقة init_pipeline() (راجع إنشاء خط أنابيب لمزيد من التفاصيل).

• تشغيل خط الأنابيب هو نفسه. بمجرد تحميله، تستدعي خط الأنابيب بنفس الحجة التي اعتدت عليها. يمكن لـ ModularPipeline واحد دعم عدة مسارات عمل (نص إلى صورة، صورة إلى صورة، inpainting، إلخ) عندما تستخدم كتل خط الأنابيب AutoPipelineBlocks لاختيار مسار العمل تلقائيًا بناءً على مدخلاتك.

فيما يلي أمثلة كاملة لتوليد الصور من النص، وتحويل الصورة إلى صورة، والتلوين الداخلي باستخدام SDXL.

import torch
from diffusers import ModularPipeline

pipeline = ModularPipeline.from_pretrained("stabilityai/stable-diffusion-xl-base-1.0")
pipeline.load_components(dtype=torch.float16)
pipeline.to("cuda")  # or "mps", "xpu", "cpu"

image = pipeline(prompt="Astronaut in a jungle, cold color palette, muted colors, detailed, 8k").images[0]
image.save("modular_t2i_out.png")

import torch
from diffusers import ModularPipeline
from diffusers.utils import load_image

pipeline = ModularPipeline.from_pretrained("stabilityai/stable-diffusion-xl-base-1.0")
pipeline.load_components(dtype=torch.float16)
pipeline.to("cuda")  # or "mps", "xpu", "cpu"

url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/sdxl-text2img.png"
init_image = load_image(url)
prompt = "a dog catching a frisbee in the jungle"
image = pipeline(prompt=prompt, image=init_image, strength=0.8).images[0]
image.save("modular_i2i_out.png")

import torch
from diffusers import ModularPipeline
from diffusers.utils import load_image

pipeline = ModularPipeline.from_pretrained("stabilityai/stable-diffusion-xl-base-1.0")
pipeline.load_components(dtype=torch.float16)
pipeline.to("cuda")  # or "mps", "xpu", "cpu"

img_url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/sdxl-text2img.png"
mask_url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/sdxl-inpaint-mask.png"

init_image = load_image(img_url)
mask_image = load_image(mask_url)

prompt = "A deep sea diver floating"
image = pipeline(prompt=prompt, image=init_image, mask_image=mask_image, strength=0.85).images[0]
image.save("modular_inpaint_out.png")

ستُظهر لك هذه الدليل كيفية إنشاء ModularPipeline، وإدارة مكوّناته، وتشغيل خط الأنابيب.

إنشاء خط أنابيب

There are two ways to create a ModularPipeline. Assemble and create a pipeline from ModularPipelineBlocks with init_pipeline(), or load an existing pipeline with from_pretrained().

يمكنك أيضًا تهيئة ComponentsManager للتعامل مع توزيع الأجهزة وإدارة الذاكرة. إذا لم تكن بحاجة إلى التفريغ التلقائي، يمكنك تجاوز هذه الخطوة ونقل خط الأنابيب إلى جهازك يدويًا باستخدام pipeline.to("cuda").

راجع وثيقة ComponentsManager لمزيد من التفاصيل حول كيفية مساعدتها في إدارة المكونات عبر سير عمل مختلفة.

init_pipeline

يحوّل init_pipeline() أي ModularPipelineBlocks إلى ModularPipeline.

لنعرّف كتلةً دنياً لنرى كيف تعمل:

from transformers import CLIPTextModel
from diffusers.modular_pipelines import (
    ComponentSpec,
    ModularPipelineBlocks,
    PipelineState,
)

class MyBlock(ModularPipelineBlocks):
    @property
    def expected_components(self):
        return [
            ComponentSpec(
                name="text_encoder",
                type_hint=CLIPTextModel,
                pretrained_model_name_or_path="openai/clip-vit-large-patch14",
            ),
        ]

    def __call__(self, components, state: PipelineState) -> PipelineState:
        return components, state

استدعِ init_pipeline() لتحويله إلى خط أنابيب. الخاصية blocks على خط الأنابيب هي الكتل التي أُنشئ منها — وهي تحدد المدخلات والمخرجات المنطوق بها ومنطق الحساب.

block = MyBlock()
pipe = block.init_pipeline()
pipe.blocks

MyBlock {
  "_class_name": "MyBlock",
  "_diffusers_version": "0.37.0.dev0"
}

المكعبات قابلة للتغيير — يمكنك بحرية إضافة مكعبات أو إزالتها أو استبدالها قبل إنشاء خط أنابيب. ومع ذلك، بمجرد إنشاء خط أنابيب، فإن تعديل pipeline.blocks لن يؤثر على خط الأنابيب لأنه يعيد نسخة. إذا كنت ترغب في بنية مكعبات مختلفة، فأنشئ خط أنابيب جديدًا بعد تعديل المكعبات.

عند استدعاء init_pipeline() دون مستودع، فإنه يستخدم pretrained_model_name_or_path المعرّف في ComponentSpec الخاص بالكتلة لتحديد مكان تحميل كل مكوّن. طباعة خط الأنابيب تعرض إعدادات تحميل المكوّنات.

pipe
ModularPipeline {
  "_blocks_class_name": "MyBlock",
  "_class_name": "ModularPipeline",
  "_diffusers_version": "0.37.0.dev0",
  "text_encoder": [
    null,
    null,
    {
      "pretrained_model_name_or_path": "openai/clip-vit-large-patch14",
      "revision": null,
      "subfolder": "",
      "type_hint": [
        "transformers",
        "CLIPTextModel"
      ],
      "variant": null
    }
  ]
}

عند تمرير مستودع إلى init_pipeline()، فإنه يتجاوز مسار التحميل عن طريق مطابقة مكونات كتلتك مع إعدادات خط الأنابيب في ذلك المستودع (model_index.json أو modular_model_index.json). راجع Modular repository لمعرفة كيفية تسجيل مواصفات التحميل وحفظها.

في المثال أدناه، سيتم تحديث pretrained_model_name_or_path إلى "stabilityai/stable-diffusion-xl-base-1.0".

pipe = block.init_pipeline("stabilityai/stable-diffusion-xl-base-1.0")
pipe
ModularPipeline {
  "_blocks_class_name": "MyBlock",
  "_class_name": "ModularPipeline",
  "_diffusers_version": "0.37.0.dev0",
  "text_encoder": [
    null,
    null,
    {
      "pretrained_model_name_or_path": "stabilityai/stable-diffusion-xl-base-1.0",
      "revision": null,
      "subfolder": "text_encoder",
      "type_hint": [
        "transformers",
        "CLIPTextModel"
      ],
      "variant": null
    }
  ]
}

إذا لم يوجد مكوّن في كتلتك في المستودع، يبقى null ويُتخطى أثناء load_components().

from_pretrained

from_pretrained() طريقة مريحة لإنشاء ModularPipeline دون الحاجة إلى تعريف الكتل بنفسك.

يعمل مع ثلاثة أنواع من المستودعات.

مستودع diffusers عادي. مرّر أي مستودع نموذج مدعوم وسيتم تعيينه تلقائيًا إلى كتل خط المعالجة الافتراضي. تشمل النماذج المدعومة حاليًا SDXL وWan وQwen وZ-Image وFlux وFlux2.

from diffusers import ModularPipeline, ComponentsManager

components = ComponentsManager()
pipeline = ModularPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", components_manager=components
)

مستودع معياري. تحتوي هذه المستودعات على modular_model_index.json يحدد فئة كل مكوّن ومن أين يتم تحميله، مع تخزين المكوّنات إلى جانبه. راجع مستودع معياري لمعرفة كيفية إنشائه.

from diffusers import ModularPipeline, ComponentsManager

components = ComponentsManager()
pipeline = ModularPipeline.from_pretrained(
    "MiniMaxAI/MiniMax-H3", components_manager=components
)

مستودع معياري يحتوي على مكوّنات مخصصة. تتضمن بعض المستودعات مكوّنات خط أنابيب مخصصة إلى جانب إعدادات التحميل. أضف trust_remote_code=True لتحميلها. راجع المكوّنات المخصصة لمعرفة كيفية إنشاء مكوّناتك الخاصة.

from diffusers import ModularPipeline, ComponentsManager

components = ComponentsManager()
pipeline = ModularPipeline.from_pretrained(
    "diffusers/Florence2-image-Annotator", trust_remote_code=True, components_manager=components
)

عندما تُعرّف كتل خط الأنابيب سير عمل (راجع pipeline.blocks.available_workflows)، مرّر workflow= للاحتفاظ بكتل سير العمل ذلك فقط — وهو نفس التقليم الذي يؤديه get_workflow(). ثم لا يُعلن خط الأنابيب إلا عن المكونات التي يستخدمها سير العمل ذلك، ويصف سطر التوثيق مدخلات سير العمل ذلك بدقة.

pipeline = ModularPipeline.from_pretrained("Qwen/Qwen-Image", workflow="inpainting")

تحميل المكونات

لا يتم إنشاء ModularPipeline تلقائياً مع المكونات. فهو يقوم فقط بتحميل التكوين ومواصفات المكونات. يمكنك تحميل المكونات باستخدام load_components().

سيؤدي هذا إلى تحميل جميع المكونات التي لديها مواصفة تحميل صالحة.

import torch

pipeline.load_components(dtype=torch.float16)

يمكنك أيضًا تحميل مكوّنات محددة بالاسم. المثال أدناه يحمّل text_encoder فقط.

pipeline.load_components(names=["text_encoder"], dtype=torch.float16)

في خط أنابيب تُعرّف كتله عملياته، يُحمّل workflow= فقط المكونات التي يستخدمها ذلك المسار. يحتفظ خط الأنابيب بجميع كتله، لذا فإن هذه هي الطريقة المريحة لتشغيل خط أنابيب واحد عبر مسارات متعددة: كل استدعاء يضيف فقط ما لا يزال المسار الجديد ينقصه.

pipeline.load_components(workflow="inpainting", dtype=torch.float16)

بعد التحميل، يُظهر طباعة خط الأنابيب المكوّنات المحمّلة — حيث تتغيّر الحقلان الأولان من null إلى مكتبة المكوّن وفئته.

pipeline

# text_encoder is loaded - shows library and class
"text_encoder": [
  "transformers",
  "CLIPTextModel",
  { ... }
]

# unet is not loaded yet - still null
"unet": [
  null,
  null,
  { ... }
]

تُمرَّر حُجج الكلمات المفتاحية مثل dtype وvariant وrevision وquantization_config إلى from_pretrained() لكل مكوّن. يمكنك تمرير قيمة واحدة لتطبيقها على جميع المكوّنات، أو تمرير قاموس (dict) لضبط قيم لكل مكوّن على حدة.

# apply bfloat16 to all components
pipeline.load_components(dtype=torch.bfloat16)

# different dtypes per component
pipeline.load_components(dtype={"transformer": torch.bfloat16, "default": torch.float32})

load_components() لا يحمّل سوى المكوّنات التي لم تُحمَّل بعد ولديها مواصفة تحميل صالحة. وهذا يعني أنه إذا كنت قد ضبطت مكوّناً مسبقاً على خطّ الأنابيب، فإن استدعاء load_components() مرة أخرى لن يُعيد تحميله.

تحديث المكونات

يستبدل update_components() مكوّنًا في خط المعالجة بمكوّن جديد. عند تحديث مكوّن، يتم أيضًا تحديث مواصفات التحميل في إعدادات خط المعالجة، وسيتم تجاوز load_components() في الاستدعاءات اللاحقة.

من AutoModel

يمكنك تمرير كائن نموذج محمّل باستخدام AutoModel.from_pretrained(). يتم وسم النماذج المحمّلة بهذه الطريقة تلقائيًا بمعلومات التحميل الخاصة بها.

from diffusers import AutoModel

unet = AutoModel.from_pretrained(
    "RunDiffusion/Juggernaut-XL-v9", subfolder="unet", variant="fp16", dtype=torch.float16
)
pipeline.update_components(unet=unet)

من ComponentSpec

استخدم get_component_spec() للحصول على نسخة من مواصفات المكوّن الحالية، ثم عدّلها، ثم حمّل مكوّناً جديداً.

unet_spec = pipeline.get_component_spec("unet")

# modify to load from a different repository
unet_spec.pretrained_model_name_or_path = "RunDiffusion/Juggernaut-XL-v9"

# load and update
unet = unet_spec.load(dtype=torch.float16)
pipeline.update_components(unet=unet)

يمكنك أيضًا إنشاء ComponentSpec من الصفر.

لا يتم تحميل جميع المكونات من أوزان مُسبقة التدريب — فبعضها يُنشأ من ملف تكوين (مُدرج تحت pipeline.config_component_names). لهذه المكونات، استخدم create() بدلاً من load().

guider_spec = pipeline.get_component_spec("guider")
guider_spec.config = {"guidance_scale": 5.0}
guider = guider_spec.create()
pipeline.update_components(guider=guider)

أو مرر الكائن مباشرةً.

from diffusers.guiders import ClassifierFreeGuidance

guider = ClassifierFreeGuidance(guidance_scale=5.0)
pipeline.update_components(guider=guider)

راجع دليل Guiders لمزيد من التفاصيل حول الأدلة المتاحة وكيفية تكوينها.

تقسيم خط الأنابيب إلى مراحل

بما أن الكتل قابلة للتركيب، يمكنك تفكيك خط الأنابيب وإعادة بنائه إلى خطوط أنابيب منفصلة لكل مرحلة. يُظهر المثال أدناه كيف يمكننا فصل كتلة مُشفّر النص عن بقية خط الأنابيب، بحيث يمكنك ترميز الأمر بشكل مستقل ثم تمرير التضمينات إلى خط الأنابيب الرئيسي.

from diffusers import ModularPipeline, ComponentsManager
import torch

device = "cuda"  # or "mps", "xpu", "cpu"
dtype = torch.bfloat16
repo_id = "black-forest-labs/FLUX.2-klein-4B"

# get the blocks and separate out the text encoder
blocks = ModularPipeline.from_pretrained(repo_id).blocks
text_block = blocks.sub_blocks.pop("text_encoder")

# use ComponentsManager to handle offloading across multiple pipelines
manager = ComponentsManager()
manager.enable_auto_cpu_offload(device=device)

# create separate pipelines for each stage
text_encoder_pipeline = text_block.init_pipeline(repo_id, components_manager=manager)
pipeline = blocks.init_pipeline(repo_id, components_manager=manager)

# encode text
text_encoder_pipeline.load_components(dtype=dtype)
text_embeddings = text_encoder_pipeline(prompt="a cat").get_by_kwargs("denoiser_input_fields")

# denoise and decode
pipeline.load_components(dtype=dtype)
output = pipeline(
    **text_embeddings,
    num_inference_steps=4,
).images[0]

يتولى ComponentsManager إدارة الذاكرة عبر خطوط أنابيب متعددة. على عكس استراتيجيات التفريغ في DiffusionPipeline التي تتبع ترتيبًا ثابتًا، يتخذ ComponentsManager قرارات التفريغ ديناميكيًا في كل مرة يُنفَّذ فيها تمرير أمامي للنموذج، بناءً على حالة الذاكرة الحالية. وهذا يعني أنه يعمل بغض النظر عن عدد خطوط الأنابيب التي تنشئها أو الترتيب الذي تنفذها به. راجد دليل ComponentsManager لمزيد من التفاصيل.

إذا كانت مراحل خط الأنابيب تتشارك في مكوّنات (مثل استخدام نفس VAE للتشفير وفك التشفير)، يمكنك استخدام update_components() لتسليم مكوّن محمّل مسبقًا إلى خط أنابيب آخر بدلاً من تحميله مرة أخرى.

مستودع معياري

يُشترط وجود مستودع إذا كانت كتل خط المعالجة تستخدم مكونات مُدرَّبة مسبقًا. يوفّر المستودع مواصفات التحميل والبيانات الوصفية.

يعمل ModularPipeline مع مستودعات diffusers العادية دون أي إعداد مسبق. ومع ذلك، يمكنك أيضاً إنشاء مستودع معياري للحصول على مرونة أكبر. يحتوي المستودع المعياري على ملف modular_model_index.json يضم العناصر الثلاثة التالية.

• library وclass يُظهران المكتبة التي تم تحميل المكوّن منها وفئته. إذا كانت null، فإن المكوّن لم يتم تحميله بعد.
• loading_specs_dict يحتوي على المعلومات المطلوبة لتحميل المكوّن، مثل المستودع والجزء الفرعي الذي يتم التحميل منه.

from diffusers import ModularPipeline

# load from a regular repo
pipeline = ModularPipeline.from_pretrained("stabilityai/stable-diffusion-xl-base-1.0")
pipeline.load_components()

# push as a modular repository
pipeline.save_pretrained("local/path", repo_id="my-username/sdxl-modular", push_to_hub=True)

بشكل افتراضي، يكتب save_pretrained() كل مكوّن محمّل حاليًا يمكن لـ Diffusers تسلسله. أما المكوّنات غير المحمّلة، أو التي لا يمكن تسلسلها، فلا تُكتب وتحتفظ بمواصفات التحميل الحالية لها.

حفظ نسخة مستقلة

load جميع المكونات، ثم احفظها. يشير كل مواصفة إلى النتيجة، لذا يتم إعادة تحميلها بالكامل من مكان واحد، بما في ذلك دون اتصال.

pipe = ModularPipeline.from_pretrained("MiniMaxAI/MiniMax-H3")
pipe.load_components()
pipe.save_pretrained("path/to/local-copy")

الموقع المُسجَّل في modular_model_index.json هو المكان الذي تكتب إليه save_pretrained(): وهو save_directory عند الحفظ محليًا، أو repo_id عند تمرير push_to_hub=True.

نقل الملفات بأي طريقة أخرى لا يعيد كتابة الفهرس. تبقى نسخة تم تنزيلها باستخدام hf download --local-dir قابلة للاستخدام: عند تحميل خط أنابيب من مجلد محلي، يتم تحميل كل مكوّن توجد ملفاتُه في ذلك المجلد من هناك بدلاً من المستودع المسجَّل. أما النسخة التي تم رفعها باستخدام hf upload فتظل تشير إلى الموقع القديم، لذا يجب تحديث الفهرس يدوياً في هذه الحالة.

مع huggingface_hub>=1.32.0، يمكن للملفات المتطابقة المدعومة بتقنية Xet أن تتشارك حمولةً واحدةً مخزنةً مؤقتًا عبر أي مستودعات Hub. ويشمل ذلك الملفات الفردية في نقطة تفتيش مقسمة: يمكن إعادة استخدام شريحة تحمل نفس تجزئة Xet حتى لو اختلفت الشرائح الأخرى. ويجب أن تستخدم عمليات التنزيل كلاهما نفس دليل التخزين المؤقت لـ Hub مع دعم الروابط الرمزية. وقد يؤدي تغيير نوع البيانات (dtype) أو طريقة التسلسل أو حدود الشرائح إلى تغيير تجزئات الملفات ومنع إعادة الاستخدام. وهذا يوفر من حركة التنزيل ومساحة القرص، وليس الذاكرة المستخدمة من قبل المكونات المحمّلة.

التخزين المؤقت المشترك يعمل على أساس أفضل جهد. ضبط HF_HUB_DISABLE_SHARED_BLOBS=1 لا يزال يدعم التحميل، لكنه يخزّن نسخًا منفصلة. تبقى مراجع المكونات الموجودة في modular_model_index.json دون تغيير؛ احتفظ بالمراجع الخارجية للمكونات غير المخزنة في المستودع المعياري.

المرجع إلى المكونات في مستودعات أخرى

يمكن أن يشير تحديد تحميل المكوّن في modular_model_index.json إلى مستودع مختلف. على سبيل المثال، يحمّل diffusers/flux2-bnb-4bit-modular محوّله المُكمَّم من diffusers/FLUX.2-dev-bnb-4bit والمكوّنات المتبقية من black-forest-labs/FLUX.2-dev.

نفضّل بشدة المستودعات المستقلة بذاتها: فإبقاء جميع المكونات معًا يجعل تنزيل خط الأنابيب ومشاركته واستخدامه دون اتصال بالإنترنت أسهل دون الاعتماد على مستودعات أخرى. استخدم مراجع المستودعات المتقاطعة فقط عندما ترغب عمدًا في استضافة مكوّن في مكان آخر.

مرّر overwrite_modular_index=False للحفاظ على مواصفات التحميل في modular_model_index.json كما هي. لا يزال المكوّن المحفوظ الذي تكون مواصفة تحميله فارغة يُملأ بالوجهة، لأنه لا يوجد شيء يجب الحفاظ عليه.

مع huggingface_hub>=1.32.0، يمكن للملفات المتطابقة المدعومة بتقنية Xet مشاركة حمولة واحدة مخزنة مؤقتًا عبر المستودعات من خلال الروابط الرمزية، مما يتجنب التنزيلات المكررة واستهلاك مساحة القرص. لا حاجة إلى مراجع بين المستودعات لهذا الغرض. راجع حفظ نسخة ذاتية الاكتفاء لمعرفة متطلبات ومحدوديات التخزين المؤقت المشترك.

تحديث فهرس معياري موجود

تستمر المراجع الموجودة إلى المستودع الأصلي في العمل. إذا كان المرجع يُستخدم فقط لتجنّب التنزيلات المكررة، فاستبدله بتحميل المكوّنات من المستودع المعياري بمجرد توفّر ملفات المكوّنات هناك.

أولاً، تحقق من أن المستودع المعياري يحتوي على تكوين المكونات نفسه وجميع ملفات الأوزان المطلوبة، بما في ذلك فهرس الأوزان وكل شريحة لنقطة تفتيش مقسمة. تحدد تجاوبات Xet أي ملفات الأوزان يمكنها إعادة استخدام ذاكرة التخزين المؤقت المشتركة. احتفظ بالمراجع إلى المكونات غير الموجودة أو التي يتم تحميلها عمدًا من نقطة تفتيش أخرى.

حرّر مواصفة التحميل ذات الصلة فقط في نسخة محلية من modular_model_index.json. على سبيل المثال، لاستخدام VAE مخزّن تحت vae/ في المستودع المعياري مع نفس متغير الأوزان:

import json
from pathlib import Path

index_path = Path("path/to/local-copy/modular_model_index.json")
index = json.loads(index_path.read_text())
spec = index["vae"][2]
spec["pretrained_model_name_or_path"] = "my-username/my-modular-repo"
spec.pop("repo", None)
spec["subfolder"] = "vae"
spec["revision"] = None
index_path.write_text(json.dumps(index, indent=2) + "\n")

يؤدي هذا أيضًا إلى إزالة حقل repo القديم. لا يُعرّف إصدار من المستودع الأصلي إصدارًا في الوجهة: استخدم None للفرع الافتراضي للوجهة، أو ثبّت إصدارًا في الوجهة يحتوي على المكوّن. عدّل subfolder وvariant إذا اختلفت أسماء الملفات.

قبل نشر الفهرس المحدّث، حمّله باستخدام ModularPipeline.from_pretrained("path/to/local-copy")، ثم استدعِ load_components(names="vae")، وتحقّق من أن المكوّن يُحمَّل بالباراميترات المتوقعة. ارفع الفهرس المُعدَّل فقط؛ فإعادة حفظ الأوزان قد تُغيّر تجزئاتها (hashes) وتمنع إعادة استخدام ذاكرة التخزين المؤقت.

كود مخصص

يمكن أن يتضمن المستودع المعياري أيضًا كتل خطوط أنابيب مخصصة على شكل كود بايثون. وهذا يتيح لك مشاركة كتل متخصصة ليست أصلية في Diffusers. على سبيل المثال، يحتوي diffusers/Florence2-image-Annotator على كتل مخصصة إلى جانب إعداد التحميل:

Florence2-image-Annotator/
├── block.py                    # Custom pipeline blocks implementation
├── config.json                 # Pipeline configuration and auto_map
├── mellon_config.json          # UI configuration for Mellon
└── modular_model_index.json    # Component loading specifications

يحتوي ملف config.json على مفتاح auto_map يخبر ModularPipeline بمكان العثور على الكتل المخصصة:

{
  "_class_name": "Florence2AnnotatorBlocks",
  "auto_map": {
    "ModularPipelineBlocks": "block.Florence2AnnotatorBlocks"
  }
}

حمّل مستودعات الأكواد المخصصة باستخدام trust_remote_code=True كما هو موضح في from_pretrained. راجع Custom blocks لمعرفة كيفية إنشاء كتل خاصة بك ومشاركتها.