Save 4 hours! We auto-setup your workflow! Free!

Drop your workflow.json — we handle every dependency, custom node, and model. Just open the link and run.

Auto-Setup Workflow Json (Free) Now!
ComfyUI > Nodes > ComfyUI-Anima-Remap > Anima Model Merge (Auto Remap)

ComfyUI Node: Anima Model Merge (Auto Remap)

Class Name

AnimaModelMerge

Category
loaders/anima
Author
shin131002 (Account age: 632days)
Extension
ComfyUI-Anima-Remap
Latest Updated
2026-11-10
Github Stars
0.03K

How to Install ComfyUI-Anima-Remap

Install this extension via the ComfyUI Manager by searching for ComfyUI-Anima-Remap
  • 1. Click the Manager button in the main menu
  • 2. Select Custom Nodes Manager button
  • 3. Enter ComfyUI-Anima-Remap in the search bar
After installation, click the Restart button to restart ComfyUI. Then, manually refresh your browser to clear the cache and access the updated list of nodes.

Visit ComfyUI Online for ready-to-use ComfyUI environment

  • Free trial available
  • 16GB VRAM to 80GB VRAM GPU machines
  • 400+ preloaded models/nodes
  • Freedom to upload custom models/nodes
  • 200+ ready-to-run workflows
  • 100% private workspace with up to 200GB storage
  • Dedicated Support

Run ComfyUI Online

Anima Model Merge (Auto Remap) Description

Merges two Anima models' weights, automatically remapping blocks across supported architectures.

Anima Model Merge (Auto Remap):

AnimaModelMerge combines the learned weights of two Anima models so you can experiment with their combined characteristics in a single generation workflow. It is displayed as “Anima Model Merge (Auto Remap)” in the loaders/anima category. When both models have the same detected number of processing blocks, it merges them directly. When their block counts differ and a suitable mapping is available, it aligns the smaller model’s blocks with their corresponding positions in the larger model rather than assuming that matching block numbers serve the same role. This is particularly useful for combining a 28-block Anima model with the 40-block Anima-2.9B architecture. The larger architecture is preserved during a successfully mapped merge, and its additional blocks can either remain unchanged or receive an experimental contribution from designated layers of the smaller model. This approach lets you explore model combinations across supported architecture sizes, although the resulting visual qualities still need to be evaluated through test generations.

Anima Model Merge (Auto Remap) Input Parameters:

model_1

A required MODEL connection supplying the first Anima model, shown as the top model input. Its contribution at matching or successfully remapped positions is controlled by merge_ratio: a higher value gives this model more influence. If both models have the same detected block count, the node clones this model as the starting point and applies the merge to that clone. If the models have different block counts and a suitable mapping is found, the larger model supplies the starting architecture regardless of which input it occupies. Connecting the smaller model here therefore does not force the result to use the smaller architecture. This input has no numeric minimum, maximum, or default; connect a compatible loaded Anima MODEL.

model_2

A required MODEL connection supplying the second Anima model. At matching or successfully remapped positions, its contribution is the complement of merge_ratio: for example, a merge_ratio of 0.7 gives model_2 a weight of 0.3. If this model has more blocks than model_1 and a suitable mapping is available, the node clones model_2 and maps the smaller model’s weights into its architecture. If both models have the same detected block count, its diffusion-model weights are applied to a clone of model_1. This input has no numeric minimum, maximum, or default; connect a compatible loaded Anima MODEL rather than a text encoder, VAE, or checkpoint file path.

merge_ratio

A required FLOAT that controls the weight of model_1 in the main merge, with a minimum of 0.0, maximum of 1.0, default of 0.5, and adjustment step of 0.01. At positions participating in this merge, the weighting is model_1 multiplied by merge_ratio plus model_2 multiplied by one minus merge_ratio. A value of 0.5 gives equal contributions, 0.8 favors model_1, and 0.2 favors model_2. This meaning remains consistent even when the node switches to the larger model as its starting architecture. For a successfully remapped merge between different block counts, this setting controls the aligned positions, not the separate extension operation on newly inserted blocks. Consequently, values of 0.0 or 1.0 do not necessarily reproduce an entire original model: the larger architecture remains, and its additional blocks are handled independently.

extend_ratio

A required FLOAT controlling how much of the smaller model’s designated source-layer weights is applied to the larger model’s newly inserted layers during a successfully remapped merge. Its minimum is 0.0, maximum is 1.0, default is 0.0, and adjustment step is 0.05. At 0.0, the extension operation is skipped and those additional layers retain the larger model’s values. At 0.5, affected tensors receive an equal blend of the larger model’s existing values and the smaller model’s source-layer values; at 1.0, they receive the source-layer values fully. For the described 28-to-40-block expansion, the source is the preceding old layer designated by the manifest, not a blend of preceding and following layers. This operation is independent of merge_ratio and is marked experimental in the logging. It only runs when a suitable architecture mapping and source-to-inserted-layer mapping are available; it has no effect in the same-block-count direct-merge branch or the unmapped fallback branch.

manifest

A required COMBO[STRING] selection identifying the mapping to resolve when the two detected block counts differ. A manifest describes how blocks from the smaller architecture correspond to positions in the larger architecture and can also identify source layers for extending weights onto newly inserted blocks. The available options are generated dynamically by list_manifest_choices(); the supplied class does not enumerate their names or explicitly declare a default, so choose from the entries available in your installation rather than relying on a fixed filename or option list. The resolver receives both the smaller and larger block counts, allowing it to seek a mapping for that particular pair. For matching detected block counts, this setting is not used. If no usable mapping is obtained, the node warns and attempts a direct merge without remapping, which may be incorrect for different architectures.

Anima Model Merge (Auto Remap) Output Parameters:

model

A MODEL containing the merged result, ready to connect to subsequent nodes that accept a ComfyUI MODEL, such as a compatible sampler workflow. When both inputs have the same recognized block count, the result keeps that block count and is based on a clone of model_1. When their block counts differ and a suitable mapping is available, the result uses the larger model’s architecture; a supported 28-block/40-block combination therefore produces a 40-block model. The aligned weights reflect merge_ratio, while any extension onto additional blocks follows extend_ratio separately. If architecture detection or mapping is unsuccessful, the fallback result is based on a clone of model_1 and is not guaranteed to be a correct architecture-aware merge. This output is a model object, not a generated image, text encoder, VAE, or automatically saved checkpoint.

Anima Model Merge (Auto Remap) Usage Tips:

  • Begin with merge_ratio at 0.5 and extend_ratio at 0.0. This gives you an equal-weight starting point at aligned positions while preserving the larger model’s additional layers during a supported cross-architecture merge.
  • To favor the top model, try merge_ratio at 0.7 or 0.8; to favor the second model, try 0.3 or 0.2. Keep the prompt, seed, sampler settings, text encoder, and VAE unchanged when comparing results so that the merge adjustment is easier to evaluate.
  • For a 28-block/40-block combination, select an available manifest appropriate to that architecture pair and check the console for confirmation of remapping and a 40-block result. A returned MODEL alone does not confirm that remapping succeeded, because the node also has a direct-merge fallback.
  • Explore extend_ratio separately from merge_ratio. After choosing a main merge balance, try extension values such as 0.05, 0.10, or 0.20 and compare generations; this isolates the effect of projecting the smaller model’s source layers onto the larger model’s added layers.
  • Leave extend_ratio at 0.0 if your goal is to preserve the larger model’s newly inserted layers. Even with merge_ratio set entirely toward the smaller model, those additional layers remain part of the larger architecture.
  • When both models have the same detected block count, focus on merge_ratio. Changing manifest or extend_ratio will not alter the direct-merge path used for that case.
  • If you need a blend between preceding and following source layers for the additional blocks, consider the separate experimental AnimaModelMergeExtended node. AnimaModelMerge itself does not expose a blend_ratio control.

Anima Model Merge (Auto Remap) Common Errors and Solutions:

No manifest covers (model_1=… , model_2=…) blocks. Falling back to an unremapped direct merge -- results may be incorrect if the architectures actually differ.

  • Explanation: This warning is emitted when the node cannot complete a mapped merge, such as when a block count is unrecognized or no usable mapping is available for the detected pair. The actual message includes the detected counts, which may be None. Execution continues with a direct merge based on model_1, but that fallback may align different architectures incorrectly.
  • Solution: Confirm that both connections are supported Anima models, inspect the detected block counts in the console, and select an installed manifest covering that pair. If no suitable mapping is available, use compatible models with the same recognized architecture rather than relying on the fallback.

Required input missing or invalid input type

  • Explanation: This is a possible ComfyUI validation problem rather than an error string explicitly defined by this class. All five inputs are required, and model_1 and model_2 must receive MODEL connections. A VAE, CLIP connection, or file path cannot replace a MODEL.
  • Solution: Connect both MODEL inputs from appropriate model-loading nodes and ensure that merge_ratio, extend_ratio, and manifest have valid selections. Use the displayed numeric ranges and the current manifest dropdown options.

Manifest selection unavailable or no usable mapping found

  • Explanation: Manifest choices are generated from the installation, so a saved workflow may refer to a selection that is no longer available. An available selection also needs to resolve to a usable mapping for the detected architecture pair. The supplied class does not define a specific missing-file or malformed-manifest error message.
  • Solution: Reselect an entry from the current dropdown and verify that the custom-node installation includes its required mapping files. If necessary, restore the extension’s supplied manifests and restart ComfyUI to reload the choices. Check the console for the actual resolver error or fallback warning before proceeding.

Tensor size mismatch or incompatible model weights

  • Explanation: A shape-related error may occur during weight application or later model execution if the two models are not compatible. This is a possible underlying framework error, not a message explicitly raised by this class. Equal block counts alone do not establish that all model components are compatible, and an unremapped fallback is especially risky when architectures differ.
  • Solution: Verify that both models belong to compatible Anima architectures. For different block counts, confirm that a suitable mapping was actually used. Test each model separately, then retry with a known compatible pair and extend_ratio at 0.0 to separate basic compatibility issues from extension behavior.

extend_ratio changes have no effect

  • Explanation: This is usually expected branch behavior rather than an execution error. Extension is only applied after a successful different-block-count remap when source-to-inserted-layer mappings exist and extend_ratio is greater than 0.0. Same-block-count merges and fallback merges skip it.
  • Solution: Check the detected block counts and look for a console entry reporting extended tensors. Use a supported smaller/larger architecture pair with a suitable manifest if you want to test extension; otherwise, adjust merge_ratio instead.

Endpoint merge does not reproduce the expected original model

  • Explanation: Setting merge_ratio to 0.0 or 1.0 controls the main merge, not every aspect of the resulting architecture. During a successfully mapped cross-architecture merge, the larger architecture remains, and its newly inserted layers follow extend_ratio independently. A nonzero extend_ratio can modify these layers even when the main merge favors only the larger model.
  • Solution: Use the original model directly when you need an unchanged baseline. To preserve the larger model through the mapped merge, favor that model fully with merge_ratio and leave extend_ratio at 0.0; do not expect favoring the smaller model fully to reconstruct its original smaller architecture.

Anima Model Merge (Auto Remap) Related Nodes

Go back to the extension to check out more related nodes.
ComfyUI-Anima-Remap
RunComfy
Copyright 2025 RunComfy. All Rights Reserved.

RunComfy is the premier ComfyUI platform, offering ComfyUI online environment and services, along with ComfyUI workflows featuring stunning visuals. RunComfy also provides AI Models, enabling artists to harness the latest AI tools to create incredible art.

Anima Model Merge (Auto Remap)