Merge Block Weights for SDXL

[wkpark]

I've been digging through the MBW presets for some time to reproduce the exact preset values, and this is the result.

simple presets

def plot(s=1.0):
    # x
    x = np.linspace(0, 1, 25)

    x[0:13] = np.linspace(0, 0.5, 13)
    x[13:25] = np.linspace(0.5-0.5/12, 0, 12)
    y = x * 2
    tmp = "GRAD_A   0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), y))
    print(tmp)
    tmp = "GRAD_V   0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), 1-y))
    print(tmp)

    # WRAP08
    x = np.linspace(0, 1, 25)
    y = np.zeros(25)
    y[0:4] = 1
    y[-4:] = 1
    tmp = "WRAP08   0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), y))
    print(tmp)

    y[0:6] = 1
    y[-6:] = 1
    tmp = "WRAP12   0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), y))
    print(tmp)

    y[0:7] = 1
    y[-7:] = 1
    tmp = "WRAP14   0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), y))
    print(tmp)

    y[0:8] = 1
    y[-8:] = 1
    tmp = "WRAP16   0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), y))
    print(tmp)

    # MID12_50 has bug.
    y = np.zeros(25)
    y[5:-6] = 0.5
    tmp = "MID12_50 0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), y))
    print(tmp)

    y = np.zeros(25)
    y[-7:] = 1
    tmp = "OUT07    0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), y))
    print(tmp)

    y = np.zeros(25)
    y[-12:] = 1
    tmp = "OUT12    0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), y))
    print(tmp)

    y = np.zeros(25)
    y[-12:] = 1
    y[-13] = 0.5
    tmp = "OUT12_5  0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), y))
    print(tmp)

    y = np.zeros(25)
    y[5] = 0.5
    y[6:9] = 1
    y[9] = 0.5
    y[15] = 0.5
    y[16:19] = 1
    y[19] = 0.5
    tmp = "RING08_SOFT  0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), y))
    print(tmp)

    y = np.zeros(25)
    y[6:10] = 1
    y[15:19] = 1
    tmp = "RING08_5 0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), y))
    print(tmp)

    y = np.zeros(25)
    y[5:10] = 1
    y[15:20] = 1
    tmp = "RING10_5 0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), y))
    print(tmp)

    y = np.zeros(25)
    y[6:11] = 1
    y[14:19] = 1
    tmp = "RING10_3 0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), y))
    print(tmp)

SMOOTHSTEPs

import numpy as np

def plot(s=1.0):
    # SMOOTHSTEP
    x = np.linspace(0, 1, 25)
    Q = 1
    x2 = x * x
    x3 = x2 * x
    y = Q * (3 * x2 - 2 * x3)
    y = y * s
    tmp = "SMOOTHSTEP   0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), y))
    print(tmp)

    Q = 2
    y = Q * (3 * x2 - 2 * x3)
    for i,yy in enumerate(y):
        if yy > 1.0:
            y[i] = Q - y[i]
    y = y * s
    tmp = "SMOOTHSTEP*2 0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), y))
    print(tmp)

    Q = 3
    y = Q * (3 * x2 - 2 * x3)
    for i,yy in enumerate(y):
        if yy > 1.0:
            y[i] = 2 - y[i]
            if y[i] < 0.0:
                y[i] = -y[i]
    y = y * s
    tmp = "SMOOTHSTEP*3 0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), y))
    print(tmp)

    Q = 4
    y = Q * (3 * x2 - 2 * x3)
    for i,yy in enumerate(y):
        if yy > 1.0:
            y[i] = 2 - y[i]
            if y[i] < 0.0:
                y[i] = -y[i]
                if y[i] > 1.0:
                    y[i] = 2 - y[i]
    y = y * s
    tmp = "SMOOTHSTEP*4 0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), y))
    print(tmp)

    # smoothstep/Q
    Q = 2
    x[0:13] = np.linspace(0, 1, 13)
    x[13:25] = np.linspace(1-1/12., 0, 12)
    x2 = x * x
    x3 = x2 * x
    y = 3 * x2 - 2 * x3
    y = y * s
    tmp = "SMOOTHSTEP/2 0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), y))
    print(tmp)

    Q = 3
    x[0:9] = np.linspace(0, 1, 9)
    x[9:17] = np.linspace(1-1/8., 0, 8)
    x[17:25] = np.linspace(0+1/8., 1, 8)
    x2 = x * x
    x3 = x2 * x    y = 3 * x2 - 2 * x3
    y = y * s
    tmp = "SMOOTHSTEP/3 0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), y))
    print(tmp)

    Q = 4
    x[0:7] = np.linspace(0, 1, 7)
    x[7:13] = np.linspace(1-1/6., 0, 6)
    x[13:19] = np.linspace(0+1/6., 1, 6)
    x[19:25] = np.linspace(1-1/6., 0, 6)
    x2 = x * x
    x3 = x2 * x
    y = 3 * x2 - 2 * x3
    y = y * s
    tmp = "SMOOTHSTEP/4 0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), y))
    print(tmp)

Cubic Hermite

I can't reproduce the TRUE_CUBIC_HERMITE. but it seems invalid. The following are corrected (I guess).
In this case, FAKE_CUBIC_HERMITE == TRUE_CUBIC_HERMITE

def plot(s=1.0):
    # true cubic hermite
    # This is corrected Cubic hermite. (FAKE_CUBIC_HERMITE is the same value)
    x = np.linspace(0, 1, 25)
    x2 = x*x
    x3 = x2 * x
    x1 = x[0]
    xn = x[24]
    S = 100/24
    # corrected eqn.
    y = (2*x3-3*x2+1)*x1 +(x3-2*x2+x)*S+(-2*x3+3*x2)*xn + (x3-x2)*S
    tmp = "TRUE_CUBIC_HERMITE   0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), y))
    print(tmp)

    tmp = "TRUE_REVERSE_CUBIC_HERMITE   0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), 1-y))
    print(tmp)

    # fake cubic hermite
    x = np.linspace(0, 1, 25)
    x2 = x*x
    x3 = x2 * x
    S = 100/24. # this STEP value could be changed easily.
    y = (x3-2*x2+x)*S + (-2*x3+3*x2) + (x3-x2)*S
    y = y * s
    tmp = "FAKE_CUBIC_HERMITE   0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), y))
    print(tmp)

    tmp = "FAKE_REVERSE_CUBIC_HERMITE   0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), 1-y))
    print(tmp)

and these results could be easily adapted on SDXL as follows.

(all simple cases are omitted)

    x = np.linspace(0, 1, 19)
    # SMOOTHSTEP
    Q = 1
    x2 = x * x
    x3 = x2 * x
    y = Q * (3 * x2 - 2 * x3)
    y = y * s
    tmp = "SMOOTHSTEP   0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), y))
    print(tmp)
    tmp = "REVERSE-SMOOTHSTEP   0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), 1 - y))
    print(tmp)

    # SMOOTHSTEP*2
    Q = 2
    y = Q * (3 * x2 - 2 * x3)
    for i,yy in enumerate(y):
        if yy > 1.0:
            y[i] = Q - y[i]
    y = y * s
    tmp = "SMOOTHSTEP*2 0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), y))
    print(tmp)
    tmp = "R_SMOOTHSTEP*2   0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), 1 - y))
    print(tmp)

    # SMOOTHSTEP*3
    Q = 3
    y = Q * (3 * x2 - 2 * x3)
    for i,yy in enumerate(y):
        if yy > 1.0:
            y[i] = 2 - y[i]
            if y[i] < 0.0:
                y[i] = -y[i]
    y = y * s
    tmp = "SMOOTHSTEP*3 0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), y))
    print(tmp)
    tmp = "R_SMOOTHSTEP*3   0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), 1 - y))
    print(tmp)

    # SMOOTHSTEP*4
    Q = 4
    y = Q * (3 * x2 - 2 * x3)
    for i,yy in enumerate(y):
        if yy > 1.0:
            y[i] = 2 - y[i]
            if y[i] < 0.0:
                y[i] = -y[i]
                if y[i] > 1.0:
                    y[i] = 2 - y[i]
    y = y * s
    tmp = "SMOOTHSTEP*4 0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), y))
    print(tmp)
    tmp = "R_SMOOTHSTEP*4   0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), 1 - y))
    print(tmp)

    # SMOOTHSTEP/2
    Q = 2
    x[0:10] = np.linspace(0, 1, 10)
    x[10:19] = np.linspace(1-1/9., 0, 9)
    x2 = x * x
    x3 = x2 * x
    y = 3 * x2 - 2 * x3
    y = y * s
    tmp = "SMOOTHSTEP/2 0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), y))
    print(tmp)
    tmp = "R_SMOOTHSTEP/2   0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), 1 - y))
    print(tmp)

    # SMOOTHSTEP/3
    Q = 3
    x[0:7] = np.linspace(0, 1, 7)
    x[7:13] = np.linspace(1-1/6., 0, 6)
    x[13:19] = np.linspace(0+1/6., 1, 6)
    x2 = x * x
    x3 = x2 * x
    y = 3 * x2 - 2 * x3
    y = y * s
    tmp = "SMOOTHSTEP/3 0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), y))
    print(tmp)
    tmp = "R_SMOOTHSTEP/3   0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), 1 - y))
    print(tmp)

    # SMOOTHSTEP/4
    Q = 4
    x[0:5] = np.linspace(0, 1., 5)
    x[5:10] = np.linspace(1-1/5., 0, 5)
    x[10:15] = np.linspace(0+1/5., 1, 5)
    x[15:19] = np.linspace(1-1/4., 0, 4)
    x2 = x * x
    x3 = x2 * x
    y = 3 * x2 - 2 * x3
    y = y * s
    tmp = "SMOOTHSTEP/4 0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), y))
    print(tmp)
    tmp = "R_SMOOTHSTEP/4   0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), 1 - y))
    print(tmp)

    # COSINE
    y = (1 - np.cos((x-1)*np.pi))/2.0
    y = y * s
    tmp = "COSINE   0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), y))
    print(tmp)
    tmp = "REVERSE_COSINE   0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), 1 - y))
    print(tmp)

    # TRUE CUBIC HERMITE
    x = np.linspace(0, 1, 19)
    x2 = x*x
    x3 = x2 * x
    x1 = x[0]
    xn = x[18]
    S = 100/18
    y = (2*x3-3*x2+1)*x1 +(x3-2*x2+x)*S+(-2*x3+3*x2)*xn + (x3-x2)*S
    y = y * s
    tmp = "CUBIC_HERMITE   0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), y))
    print(tmp)

    tmp = "REVERSE_CUBIC_HERMITE   0," + ",".join(map(lambda x: str(int(x)) if x == int(x) else str(x), 1-y))
    print(tmp)

These are the final presets for SDXL

• OUT12, OUT12_5 removed, OUT09, OUT09_5 added.

GRAD_V  0,1,0.8888888888888888,0.7777777777777778,0.6666666666666667,0.5555555555555556,0.4444444444444444,0.33333333333333337,0.22222222222222232,0.11111111111111116,0,0.11111111111111116,0.22222222222222232,0.33333333333333337,0.4444444444444444,0.5555555555555556,0.6666666666666667,0.7777777777777778,0.8888888888888888,1
GRAD_A  0,0,0.11111111111111116,0.2222222222222222,0.33333333333333326,0.4444444444444444,0.5555555555555556,0.6666666666666666,0.7777777777777777,0.8888888888888888,1,0.8888888888888888,0.7777777777777777,0.6666666666666666,0.5555555555555556,0.4444444444444444,0.33333333333333326,0.2222222222222222,0.11111111111111116,0
FLAT_25 0,0.25,0.25,0.25,0.25,0.25,0.25,0.25,0.25,0.25,0.25,0.25,0.25,0.25,0.25,0.25,0.25,0.25,0.25,0.25
FLAT_75 0,0.75,0.75,0.75,0.75,0.75,0.75,0.75,0.75,0.75,0.75,0.75,0.75,0.75,0.75,0.75,0.75,0.75,0.75,0.75
WRAP08  0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1
WRAP12  0,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1
WRAP14  0,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1
WRAP16  0,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1
MID12_50    0,0,0,0,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5,0,0,0
OUT07   0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1
OUT09   0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1
OUT09_5 0,0,0,0,0,0,0,0,0,0,0.5,1,1,1,1,1,1,1,1,1
RING08_SOFT 0,0,0,0.5,1,1,1,0.5,0,0,0,0,0,0.5,1,1,1,0.5,0,0
RING08_5    0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0
RING10_5    0,0,0,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1,0,0
RING10_3    0,0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1,0,0,0
SMOOTHSTEP  0,0,0.008916323731138546,0.03429355281207133,0.07407407407407407,0.1262002743484225,0.18861454046639234,0.25925925925925924,0.33607681755829893,0.41700960219478733,0.5,0.5829903978052127,0.6639231824417009,0.7407407407407407,0.8113854595336077,0.8737997256515774,0.925925925925926,0.9657064471879286,0.9910836762688613,1
REVERSE-SMOOTHSTEP  0,1,0.9910836762688614,0.9657064471879286,0.9259259259259259,0.8737997256515775,0.8113854595336076,0.7407407407407407,0.6639231824417011,0.5829903978052127,0.5,0.41700960219478733,0.3360768175582991,0.2592592592592593,0.18861454046639226,0.12620027434842263,0.07407407407407396,0.03429355281207136,0.008916323731138709,0
SMOOTHSTEP*2    0,0,0.01783264746227709,0.06858710562414266,0.14814814814814814,0.252400548696845,0.3772290809327847,0.5185185185185185,0.6721536351165979,0.8340192043895747,1,0.8340192043895747,0.6721536351165982,0.5185185185185186,0.3772290809327845,0.25240054869684525,0.14814814814814792,0.06858710562414272,0.017832647462277418,0
R_SMOOTHSTEP*2  0,1,0.9821673525377229,0.9314128943758573,0.8518518518518519,0.747599451303155,0.6227709190672153,0.4814814814814815,0.32784636488340213,0.16598079561042534,0,0.16598079561042534,0.3278463648834018,0.4814814814814814,0.6227709190672155,0.7475994513031547,0.8518518518518521,0.9314128943758573,0.9821673525377226,1
SMOOTHSTEP*3    0,0,0.026748971193415638,0.102880658436214,0.2222222222222222,0.37860082304526743,0.565843621399177,0.7777777777777777,0.9917695473251031,0.748971193415638,0.5,0.251028806584362,0.008230452674897304,0.22222222222222232,0.43415637860082334,0.621399176954732,0.7777777777777781,0.8971193415637861,0.9732510288065841,1
R_SMOOTHSTEP*3  0,1,0.9732510288065843,0.897119341563786,0.7777777777777778,0.6213991769547326,0.434156378600823,0.22222222222222232,0.00823045267489686,0.251028806584362,0.5,0.748971193415638,0.9917695473251027,0.7777777777777777,0.5658436213991767,0.378600823045268,0.22222222222222188,0.10288065843621386,0.026748971193415905,0
SMOOTHSTEP*4    0,0,0.03566529492455418,0.13717421124828533,0.2962962962962963,0.50480109739369,0.7544581618655694,0.962962962962963,0.6556927297668043,0.33196159122085067,0,0.33196159122085067,0.6556927297668036,0.9629629629629628,0.754458161865569,0.5048010973936905,0.29629629629629584,0.13717421124828544,0.035665294924554836,0
R_SMOOTHSTEP*4  0,1,0.9643347050754458,0.8628257887517147,0.7037037037037037,0.49519890260631005,0.24554183813443065,0.03703703703703698,0.34430727023319574,0.6680384087791493,1,0.6680384087791493,0.3443072702331964,0.0370370370370372,0.24554183813443098,0.4951989026063095,0.7037037037037042,0.8628257887517146,0.9643347050754452,1
SMOOTHSTEP/2    0,0,0.03429355281207133,0.1262002743484225,0.25925925925925924,0.41700960219478733,0.5829903978052127,0.7407407407407407,0.8737997256515774,0.9657064471879286,1,0.9657064471879286,0.8737997256515774,0.7407407407407407,0.5829903978052127,0.41700960219478733,0.2592592592592592,0.1262002743484225,0.03429355281207136,0
R_SMOOTHSTEP/2  0,1,0.9657064471879286,0.8737997256515775,0.7407407407407407,0.5829903978052127,0.41700960219478733,0.2592592592592593,0.12620027434842263,0.03429355281207136,0,0.03429355281207136,0.12620027434842263,0.2592592592592593,0.41700960219478733,0.5829903978052127,0.7407407407407408,0.8737997256515775,0.9657064471879286,1
SMOOTHSTEP/3    0,0,0.07407407407407407,0.25925925925925924,0.5,0.7407407407407407,0.925925925925926,1,0.9259259259259258,0.7407407407407407,0.5,0.2592592592592593,0.07407407407407404,0,0.07407407407407407,0.2592592592592593,0.5,0.7407407407407407,0.9259259259259258,1
R_SMOOTHSTEP/3  0,1,0.9259259259259259,0.7407407407407407,0.5,0.2592592592592593,0.07407407407407396,0,0.07407407407407418,0.2592592592592593,0.5,0.7407407407407407,0.9259259259259259,1,0.9259259259259259,0.7407407407407407,0.5,0.2592592592592593,0.07407407407407418,0
SMOOTHSTEP/4    0,0,0.15625,0.5,0.84375,1,0.8960000000000001,0.6480000000000001,0.3520000000000001,0.10399999999999995,0,0.10400000000000002,0.3520000000000001,0.6480000000000001,0.8960000000000001,1,0.84375,0.5,0.15625,0
R_SMOOTHSTEP/4  0,1,0.84375,0.5,0.15625,0,0.10399999999999987,0.35199999999999987,0.6479999999999999,0.896,1,0.896,0.6479999999999999,0.35199999999999987,0.10399999999999987,0,0.15625,0.5,0.84375,1
COSINE  0,1,0.8535533905932737,0.49999999999999994,0.1464466094067262,0,0.09549150281252627,0.34549150281252616,0.6545084971874737,0.9045084971874737,1,0.9045084971874737,0.6545084971874737,0.34549150281252616,0.09549150281252627,0,0.1464466094067262,0.49999999999999994,0.8535533905932737,1
REVERSE_COSINE  0,0,0.14644660940672627,0.5,0.8535533905932737,1,0.9045084971874737,0.6545084971874738,0.3454915028125263,0.09549150281252627,0,0.09549150281252627,0.3454915028125263,0.6545084971874738,0.9045084971874737,1,0.8535533905932737,0.5,0.14644660940672627,0
CUBIC_HERMITE   0,0,0.2680231672001219,0.46105776558451456,0.5884773662551439,0.6596555403139764,0.683965858862978,0.6707818930041152,0.629477213839354,0.5694253924706599,0.5,0.43057460752933996,0.3705227861606464,0.3292181069958847,0.31603414113702244,0.3403444596860239,0.41152263374485576,0.5389422344154853,0.7319768327998775,1
REVERSE_CUBIC_HERMITE   0,1,0.7319768327998781,0.5389422344154855,0.4115226337448561,0.34034445968602356,0.316034141137022,0.32921810699588483,0.37052278616064604,0.43057460752934007,0.5,0.56942539247066,0.6294772138393536,0.6707818930041153,0.6839658588629776,0.6596555403139761,0.5884773662551442,0.4610577655845147,0.26802316720012254,0

The preset weights in SDXL can be easily distinguished from SD by the different counting number of them.
Aside from the fact that the UI could be a bit confusing, we can support both SD and SDXL with a small fix.

See also wkpark/sd-webui-model-mixer#2