Hi, I also use A1111 and it does appear for me, although if you type "<" in the prompt it usually gives you the option to choose hidden files, although I use Google Colab so I don't know if it will work for you.

@aaUn17 Thanks for using it. By the way, the Duplo version is almost a complete checkpoint, so you don't need to run it at full power; only Lite needs it. I also recommend using the --fp8 argument if you have limited VRAM.

Hi, I use Colab. I used to use another script, but after testing it on 20 popular checkpoints like YiffyMIX, I realized that layer 11 always gets corrupted. : import torch

from safetensors.torch import load_file

modelos = [

"/content/drive/MyDrive/qupdt1/HerrscherAGGA2025_UTOPIA-XL_V5-ALPHA.fp16.safetensors",

]

for m_path in modelos:

print(f"Comprobando {m_path.split('/')[-1]}...")

try:

weights = load_file(m_path)

bad = [k for k in weights.keys() if "layers.11" in k and (torch.isnan(weights[k]).any() or torch.isinf(weights[k]).any())]

if bad:

print(f" ❌ It has {len(bad)} corrupted tensors in layer 11.")

else:

print(" ✅ It's clean.")

except:

print(" ⚠️ It could not be loaded.")

---------------------------------------------------------------------------------------------------

simple solution:

import torch

from safetensors.torch import load_file, save_file

import gc

# 1. ROUTES

# We will use Illustrious/NoobAI as a donor because we have confirmed that it is 100% clean.

ruta_master_con_nans = "/content/HerrscherAGGA2025_Velvette-XL_V4_Noblesse_FOCUS.safetensors"

ruta_donante_sano = "/content/noobaiXLNAIXL_epsilonPred11Version.safetensors"

ruta_salida_parcheada = "/content/HerrscherAGGA2025_Velvette-XL_V4_Noblesse_FOCUS_PATCHED.safetensors"

print("🩹Initiating surgical patching of Layer 11...")

# 2. Load models

master = load_file(ruta_master_con_nans)

sano = load_file(ruta_donante_sano)

# 3. Identify and replace only the broken tensioners in Layer 11

parches = 0

# We specifically looked at the CLIP architecture (conditioner)

keys_a_revisar = [k for k in master.keys() if "layers.11" in k]

for key in keys_a_revisar:

if torch.isnan(master[key]).any() or torch.isinf(master[key]).any():

print(f"🔥 Repairing an infected tensioner: {key}")

if key in sano:

# Direct replacement for the sound value of Illustrious / NoobAI

master[key] = sano[key].to(master[key].dtype)

parches += 1

else:

# If it's not in the donor (unlikely), we clean with zeros.

master[key] = torch.nan_to_num(master[key], nan=0.0)

parches += 1

# 4. Final verification (Safety cleaning of the entire model)

for key in master.keys():

if torch.isnan(master[key]).any() or torch.isinf(master[key]).any():

master[key] = torch.nan_to_num(master[key], nan=0.0)

# 5. Save

print(f"\n✅ Surgery completed. Specific {patches] were applied.")

save_file(master, ruta_salida_parcheada)

print(f"💾 Save on: {ruta_salida_parcheada}")

# Cleaning

of the master, healthy

gc.collect()

@Sexiam The problem with merging is that NaNs are infectious. In math, Normal Value + NaN = NaN. So, if you merge 10 models and just one of them has a fried Layer 11, your entire resulting merge will inherit that corruption. That's why checking and patching it with a clean donor is crucial.

@Sexiam Also, it's usually a math issue called [[Arithmetic Overflow]] during the calculation.

In aggressive finetunes, Layer 11 tends to have extremely high parameter values because it acts as the bottleneck for the skipped Layer 12. It's basically a cup filled to the brim.

When you merge two models (especially using methods like 'Add Difference'), you are adding those values together (A + B). Since Layer 11 is already near the max limit of the fp16 format, adding even a small value pushes it over the edge. The number becomes too big for the file format, and it instantly turns into a NaN (corrupted tensors in layer 11).

That's why patching involves replacing it with a 'calmer' layer (like NoobAI's) that has lower values, keeping the math within safe limits.

@Sexiam Aha!, Switching to fp32 absolutely solves the immediate math overflow because the limit is virtually infinite compared to fp16.

Since Layer 11 is exactly where values tend to explode, fp32 technically "fixes" the crash during the merge process because it can handle those massive numbers.

However, you're just kicking the can down the road. The underlying issue is that Layer 11 is still outputting values way above the fp16 safe zone. So if you go the fp32 route, you must clamp the values before saving. Otherwise, the moment you convert back to fp16 for distribution, those huge values will hit the limit again and turn right back into NaNs.

@aaUn17 Hi, it's simple. A checkpoint is a zip file, and this zip file contains folders for reading, style, and attachment. The style is called CLIP (this includes CLIP L and OpenCLIP G).

Think of it this way:

CLIP: This is what reads your prompt ("1 girl, hat..."). It has several layers; imagine they are pages of an instruction manual. The famous Layer 11 is almost the last page. If that page has ink smudges (NaNs/Errors), the model gets confused right at the end and doesn't know what to draw.

UNet: This is what actually paints the image based on what the brain (clip) told it.

VAE: This converts the math into the final image you see.

What I do with my script is simply tear that broken "page 11" out of the Brain and paste a new, clean page from another book (NoobAI) onto it. It's that simple! It's not black magic, it's just replacing a faulty part. 😉