Uso de bloques personalizados con Mellon

Mellon es una interfaz de flujo de trabajo visual que se integra con Modular Diffusers y está diseñada para flujos de trabajo basados en nodos.

Mellon se encuentra en una fase temprana de desarrollo y aún no está listo para su uso en producción. ¡Considere esto como una vista previa de cómo funciona la integración!

Los bloques personalizados funcionan en Mellon sin configuración adicional: solo es necesario añadir un mellon_pipeline_config.json a tu repositorio. Este archivo de configuración indica a Mellon cómo renderizar los parámetros de tu bloque como componentes de interfaz de usuario.

Así es como se ve en acción con el bloque Gemini Prompt Expander:

Mellon custom block demo

Para usar un bloque personalizado modular de diffusers en Mellon:

Arrastra un Dynamic Block Node desde la sección ModularDiffusers
Introduce el repo_id (p. ej., diffusers/gemini-prompt-expander-mellon)
Haz clic en Cargar bloque personalizado
El nodo se transforma para mostrar las entradas y salidas de tu bloque

Ahora veamos cómo crear esta configuración para tu propio bloque personalizado.

Pasos para crear una configuración de Mellon

Especifique los tipos de Mellon para sus parámetros - Cada InputParam/OutputParam necesita un tipo que indique a Mellon qué componente de interfaz de usuario debe renderizar (p. ej., "textbox", "dropdown", "image").
Generar mellon_pipeline_config.json - Utilice nuestra utilidad para generar una plantilla de configuración y subirla a su repositorio de Hub.
(Opcional) Ajustar manualmente la configuración - Ajusta la configuración generada para tus necesidades específicas.

Especificar tipos Mellon para parámetros

Los tipos de Mellon determinan cómo se renderiza cada parámetro en la interfaz de usuario. Si no especifica un tipo para un parámetro, se usará "custom" de forma predeterminada, lo que se renderiza como un punto de conexión simple. Siempre puede ajustar esto más adelante en la configuración generada.

Tipo	Entrada/Salida	Descripción
`image`	Ambos	Imagen (PIL Image)
`video`	Ambos	Video
`text`	Ambos	Mostrar texto
`textbox`	Entrada	Entrada de texto
`dropdown`	Entrada	Menú desplegable de selección
`slider`	Entrada	Deslizador para valores numéricos
`number`	Entrada	Entrada numérica
`checkbox`	Entrada	Interruptor booleano

Para los parámetros que requieren más configuración (como menús desplegables con opciones o deslizadores con valores mín/máx), pase directamente una instancia de MellonParam en lugar de una cadena de texto. Puede utilizar uno de los métodos de clase a continuación o crear uno totalmente personalizado con MellonParam(name, label, type, ...).

Método	Descripción
`MellonParam.Input.image(name)`	Entrada de imagen
`MellonParam.Input.textbox(name, default)`	Entrada de texto como textarea
`MellonParam.Input.dropdown(name, options, default)`	Selección desplegable
`MellonParam.Input.slider(name, default, min, max, step)`	Deslizador para valores numéricos
`MellonParam.Input.number(name, default, min, max, step)`	Entrada numérica (sin control deslizante)
`MellonParam.Input.seed(name, default)`	Entrada de semilla con botón de aleatorización
`MellonParam.Input.checkbox(name, default)`	Casilla de verificación booleana
`MellonParam.Input.model(name)`	Entrada del modelo para los componentes de diffusers
`MellonParam.Output.image(name)`	Salida de imagen
`MellonParam.Output.video(name)`	Salida de video
`MellonParam.Output.text(name)`	Salida de texto
`MellonParam.Output.model(name)`	Salida del modelo para los componentes de diffusers

Elija uno de los métodos siguientes para especificar un tipo de Mellon.

Uso de metadatos en definiciones de bloques

Si estás definiendo un bloque personalizado desde cero, añade metadata={"mellon": "<type>"} directamente a tus definiciones de InputParam y OutputParam. Si estás editando un bloque personalizado existente del Hub, consulta Editing custom blocks para saber cómo descargarlo localmente.

class GeminiPromptExpander(ModularPipelineBlocks):
    
    @property
    def inputs(self) -> List[InputParam]:
        return [
            InputParam(
                "prompt",
                type_hint=str,
                required=True,
                description="Prompt to use",
                metadata={"mellon": "textbox"},  # Text input
            )
        ]
    
    @property
    def intermediate_outputs(self) -> List[OutputParam]:
        return [
            OutputParam(
                "prompt",
                type_hint=str,
                description="Expanded prompt by the LLM",
                metadata={"mellon": "text"},  # Text output
            ),
            OutputParam(
                "old_prompt",
                type_hint=str,
                description="Old prompt provided by the user",
<CopyLLMTxtMenu containerStyle="float: inline-end; margin-inline-start: 10px; display: inline-flex; position: relative; z-index: 10;"></CopyLLMTxtMenu>

                # No metadata - we don't want to render this in UI
            )
        ]

Para tener un control total sobre la configuración de la interfaz de usuario, pase directamente una instancia de MellonParam:

from diffusers.modular_pipelines.mellon_node_utils import MellonParam

InputParam(
    "mode",
    type_hint=str,
    default="balanced",
    metadata={"mellon": MellonParam.Input.dropdown("mode", options=["fast", "balanced", "quality"])},
)

Uso de input_types y output_types al generar la configuración

Si estás trabajando con un pipeline existente o prefieres mantener limpias tus definiciones de bloques, especifica los tipos al generar la configuración usando el argumento input_types/output_types:

from diffusers.modular_pipelines.mellon_node_utils import MellonPipelineConfig

mellon_config = MellonPipelineConfig.from_custom_block(
    blocks,
    input_types={"prompt": "textbox"},
    output_types={"prompt": "text"}
)

Cuando se especifican tanto metadata como input_types/output_types, los argumentos tienen prioridad sobre metadata.

Generar y enviar la configuración de Mellon

Después de añadir metadatos a tu bloque, genera la plantilla de configuración predeterminada de Mellon y súbela al Hub:

from diffusers import ModularPipelineBlocks
from diffusers.modular_pipelines.mellon_node_utils import MellonPipelineConfig

# load your custom blocks from your local dir
blocks = ModularPipelineBlocks.from_pretrained("/path/local/folder", trust_remote_code=True)

# Generate the default config template
mellon_config = MellonPipelineConfig.from_custom_block(blocks)
# push the default template to `repo_id`, you will need to pass the same local folder path so that it will save the config locally first
mellon_config.save(
    local_dir="/path/local/folder",
    repo_id= repo_id,
    push_to_hub=True
)

Esto crea un archivo mellon_pipeline_config.json en tu repositorio.

Revisar y ajustar la configuración

La plantilla generada es un punto de partida; es posible que desees ajustarla según tus necesidades. Repasemos la configuración generada para el Gemini Prompt Expander:

{
  "label": "Gemini Prompt Expander",
  "default_repo": "",
  "default_dtype": "",
  "node_params": {
    "custom": {
      "params": {
        "prompt": {
          "label": "Prompt",
          "type": "string",
          "display": "textarea",
          "default": ""
        },
        "out_prompt": {
          "label": "Prompt",
          "type": "string",
          "display": "output"
        },
        "old_prompt": {
          "label": "Old Prompt",
          "type": "custom",
          "display": "output"
        },
        "doc": {
          "label": "Doc",
          "type": "string",
          "display": "output"
        }
      },
      "input_names": ["prompt"],
      "model_input_names": [],
      "output_names": ["out_prompt", "old_prompt", "doc"],
      "block_name": "custom",
      "node_type": "custom"
    }
  }
}

Comprensión de la estructura

El diccionario params define cómo se renderiza cada elemento de la interfaz de usuario. Las listas input_names, model_input_names y output_names mapean estos elementos de la interfaz de usuario a la interfaz de entrada/salida de los ModularPipelineBlocks subyacentes:

Configuración de Mellon	ModularPipelineBlocks
`input_names`	propiedad `inputs`
`model_input_names`	propiedad `expected_components`
`output_names`	propiedad `intermediate_outputs`

En este ejemplo: prompt es la única entrada. No hay componentes del modelo, y las salidas incluyen out_prompt, old_prompt y doc.

Ahora veamos el diccionario params:

prompt: Un parámetro de entrada con display: "textarea" (se renderiza como un cuadro de entrada de texto), label: "Prompt" (se muestra en la interfaz) y default: "" (comienza vacío). El campo type: "string" es importante en Mellon porque determina qué nodos pueden conectarse entre sí: solo los tipos coincidentes pueden enlazarse con “noodles”.
out_prompt: La salida del prompt expandido. El prefijo out_ se añadió automáticamente porque la entrada y la salida comparten el mismo nombre (prompt), evitando conflictos de nombres en la configuración. Tiene display: "output", lo que se renderiza como un socket de salida.
old_prompt: Tiene type: "custom" porque no especificamos metadatos. Esto se renderiza como un punto simple en la interfaz. Dado que en realidad no queremos exponerlo en la interfaz, podemos eliminarlo.
doc: La salida de la documentación, añadida automáticamente a todos los bloques personalizados.

Realizar ajustes

Elimina old_prompt de params y output_names porque no lo necesitarás.

{
  "label": "Gemini Prompt Expander",
  "default_repo": "",
  "default_dtype": "",
  "node_params": {
    "custom": {
      "params": {
        "prompt": {
          "label": "Prompt",
          "type": "string",
          "display": "textarea",
          "default": ""
        },
        "out_prompt": {
          "label": "Prompt",
          "type": "string",
          "display": "output"
        },
        "doc": {
          "label": "Doc",
          "type": "string",
          "display": "output"
        }
      },
      "input_names": ["prompt"],
      "model_input_names": [],
      "output_names": ["out_prompt", "doc"],
      "block_name": "custom",
      "node_type": "custom"
    }
  }
}

Vea la configuración final en diffusers/gemini-prompt-expander-mellon.

Update on GitHub