| import argparse |
| import gc |
| import os |
| import os.path |
| import re |
| import shutil |
| from importlib import reload |
| from pprint import pprint |
| import gradio as gr |
| from modules import (devices, script_callbacks, scripts, sd_hijack, sd_models,sd_vae, shared) |
| from modules.scripts import basedir |
| from modules.sd_models import checkpoints_loaded |
| from modules.shared import opts |
| from modules.ui import create_output_panel, create_refresh_button |
| import scripts.mergers.mergers |
| import scripts.mergers.pluslora |
| import scripts.mergers.xyplot |
| reload(scripts.mergers.mergers) |
| reload(scripts.mergers.xyplot) |
| reload(scripts.mergers.pluslora) |
| import csv |
| import scripts.mergers.pluslora as pluslora |
| from scripts.mergers.mergers import (TYPESEG, freezemtime, rwmergelog, simggen,smergegen) |
| from scripts.mergers.xyplot import freezetime, nulister, numaker, numanager |
|
|
| gensets=argparse.Namespace() |
|
|
| def on_ui_train_tabs(params): |
| txt2img_preview_params=params.txt2img_preview_params |
| gensets.txt2img_preview_params=txt2img_preview_params |
| return None |
|
|
| path_root = basedir() |
|
|
| def on_ui_tabs(): |
| weights_presets="" |
| userfilepath = os.path.join(path_root, "scripts","mbwpresets.txt") |
| if os.path.isfile(userfilepath): |
| try: |
| with open(userfilepath) as f: |
| weights_presets = f.read() |
| filepath = userfilepath |
| except OSError as e: |
| pass |
| else: |
| filepath = os.path.join(path_root, "scripts","mbwpresets_master.txt") |
| try: |
| with open(filepath) as f: |
| weights_presets = f.read() |
| shutil.copyfile(filepath, userfilepath) |
| except OSError as e: |
| pass |
|
|
| with gr.Blocks() as supermergerui: |
| with gr.Tab("Merge"): |
| with gr.Row().style(equal_height=False): |
| with gr.Column(scale = 3): |
| gr.HTML(value="<p>Merge models and load it for generation</p>") |
|
|
| with gr.Row(): |
| model_a = gr.Dropdown(sd_models.checkpoint_tiles(),elem_id="model_converter_model_name",label="Model A",interactive=True) |
| create_refresh_button(model_a, sd_models.list_models,lambda: {"choices": sd_models.checkpoint_tiles()},"refresh_checkpoint_Z") |
|
|
| model_b = gr.Dropdown(sd_models.checkpoint_tiles(),elem_id="model_converter_model_name",label="Model B",interactive=True) |
| create_refresh_button(model_b, sd_models.list_models,lambda: {"choices": sd_models.checkpoint_tiles()},"refresh_checkpoint_Z") |
|
|
| model_c = gr.Dropdown(sd_models.checkpoint_tiles(),elem_id="model_converter_model_name",label="Model C",interactive=True) |
| create_refresh_button(model_c, sd_models.list_models,lambda: {"choices": sd_models.checkpoint_tiles()},"refresh_checkpoint_Z") |
|
|
| mode = gr.Radio(label = "Merge Mode",choices = ["Weight sum:A*(1-alpha)+B*alpha", "Add difference:A+(B-C)*alpha", |
| "Triple sum:A*(1-alpha-beta)+B*alpha+C*beta", |
| "sum Twice:(A*(1-alpha)+B*alpha)*(1-beta)+C*beta", |
| ], value = "Weight sum:A*(1-alpha)+B*alpha") |
| calcmode = gr.Radio(label = "Calcutation Mode",choices = ["normal", "cosineA", "cosineB", "smoothAdd","tensor"], value = "normal") |
| with gr.Row(): |
| useblocks = gr.Checkbox(label="use MBW") |
| base_alpha = gr.Slider(label="alpha", minimum=-1.0, maximum=2, step=0.001, value=0.5) |
| base_beta = gr.Slider(label="beta", minimum=-1.0, maximum=2, step=0.001, value=0.25) |
| |
|
|
| with gr.Row(): |
| merge = gr.Button(elem_id="model_merger_merge", value="Merge!",variant='primary') |
| mergeandgen = gr.Button(elem_id="model_merger_merge", value="Merge&Gen",variant='primary') |
| gen = gr.Button(elem_id="model_merger_merge", value="Gen",variant='primary') |
| stopmerge = gr.Button(elem_id="stopmerge", value="Stop",variant='primary') |
| with gr.Row(): |
| with gr.Column(scale = 4): |
| save_sets = gr.CheckboxGroup(["save model", "overwrite","safetensors","fp16","save metadata"], value=["safetensors"], label="save settings") |
| with gr.Column(scale = 2): |
| id_sets = gr.CheckboxGroup(["image", "PNG info"], label="write merged model ID to") |
| with gr.Row(): |
| with gr.Column(min_width = 50, scale=2): |
| with gr.Row(): |
| custom_name = gr.Textbox(label="Custom Name (Optional)", elem_id="model_converter_custom_name") |
| mergeid = gr.Textbox(label="merge from ID", elem_id="model_converter_custom_name",value = "-1") |
| with gr.Column(min_width = 50, scale=1): |
| with gr.Row():s_reverse= gr.Button(value="Set from ID(-1 for last)",variant='primary') |
|
|
| with gr.Accordion("Restore faces, Tiling, Hires. fix, Batch size",open = False): |
| batch_size = denois_str = gr.Slider(minimum=0, maximum=8, step=1, label='Batch size', value=1, elem_id="sm_txt2img_batch_size") |
| genoptions = gr.CheckboxGroup(label = "Gen Options",choices=["Restore faces", "Tiling", "Hires. fix"], visible = True,interactive=True,type="value") |
| with gr.Row(elem_id="txt2img_hires_fix_row1", variant="compact"): |
| hrupscaler = gr.Dropdown(label="Upscaler", elem_id="txt2img_hr_upscaler", choices=[*shared.latent_upscale_modes, *[x.name for x in shared.sd_upscalers]], value=shared.latent_upscale_default_mode) |
| hr2ndsteps = gr.Slider(minimum=0, maximum=150, step=1, label='Hires steps', value=0, elem_id="txt2img_hires_steps") |
| denois_str = gr.Slider(minimum=0.0, maximum=1.0, step=0.01, label='Denoising strength', value=0.7, elem_id="txt2img_denoising_strength") |
| hr_scale = gr.Slider(minimum=1.0, maximum=4.0, step=0.05, label="Upscale by", value=2.0, elem_id="txt2img_hr_scale") |
| |
| hiresfix = [genoptions,hrupscaler,hr2ndsteps,denois_str,hr_scale] |
|
|
| with gr.Accordion("Elemental Merge",open = False): |
| with gr.Row(): |
| esettings1 = gr.CheckboxGroup(label = "settings",choices=["print change"],type="value",interactive=True) |
| with gr.Row(): |
| deep = gr.Textbox(label="Blocks:Element:Ratio,Blocks:Element:Ratio,...",lines=2,value="") |
| |
| with gr.Accordion("Tensor Merge",open = False,visible=False): |
| tensor = gr.Textbox(label="Blocks:Tensors",lines=2,value="") |
| |
| with gr.Row(): |
| x_type = gr.Dropdown(label="X type", choices=[x for x in TYPESEG], value="alpha", type="index") |
| x_randseednum = gr.Number(value=3, label="number of -1", interactive=True, visible = True) |
| xgrid = gr.Textbox(label="Sequential Merge Parameters",lines=3,value="0.25,0.5,0.75") |
| y_type = gr.Dropdown(label="Y type", choices=[y for y in TYPESEG], value="none", type="index") |
| ygrid = gr.Textbox(label="Y grid (Disabled if blank)",lines=3,value="",visible =False) |
| with gr.Row(): |
| gengrid = gr.Button(elem_id="model_merger_merge", value="Sequential XY Merge and Generation",variant='primary') |
| stopgrid = gr.Button(elem_id="model_merger_merge", value="Stop XY",variant='primary') |
| s_reserve1 = gr.Button(value="Reserve XY Plot",variant='primary') |
| dtrue = gr.Checkbox(value = True, visible = False) |
| dfalse = gr.Checkbox(value = False,visible = False) |
| dummy_t = gr.Textbox(value = "",visible = False) |
| blockid=["BASE","IN00","IN01","IN02","IN03","IN04","IN05","IN06","IN07","IN08","IN09","IN10","IN11","M00","OUT00","OUT01","OUT02","OUT03","OUT04","OUT05","OUT06","OUT07","OUT08","OUT09","OUT10","OUT11"] |
| |
| with gr.Column(scale = 2): |
| currentmodel = gr.Textbox(label="Current Model",lines=1,value="") |
| submit_result = gr.Textbox(label="Message") |
| mgallery, mgeninfo, mhtmlinfo, mhtmllog = create_output_panel("txt2img", opts.outdir_txt2img_samples) |
| with gr.Row(visible = False) as row_inputers: |
| inputer = gr.Textbox(label="",lines=1,value="") |
| addtox = gr.Button(value="Add to Sequence X") |
| addtoy = gr.Button(value="Add to Sequence Y") |
| with gr.Row(visible = False) as row_blockids: |
| blockids = gr.CheckboxGroup(label = "block IDs",choices=[x for x in blockid],type="value",interactive=True) |
| with gr.Row(visible = False) as row_calcmode: |
| calcmodes = gr.CheckboxGroup(label = "calcmode",choices=["normal", "cosineA", "cosineB", "smoothAdd","tensor"],type="value",interactive=True) |
| with gr.Row(visible = False) as row_checkpoints: |
| checkpoints = gr.CheckboxGroup(label = "checkpoint",choices=[x.model_name for x in sd_models.checkpoints_list.values()],type="value",interactive=True) |
| with gr.Row(visible = False) as row_esets: |
| esettings = gr.CheckboxGroup(label = "effective chekcer settings",choices=["save csv","save anime gif","not save grid","print change"],type="value",interactive=True) |
| |
| with gr.Tab("Weights Setting"): |
| with gr.Row(): |
| setalpha = gr.Button(elem_id="copytogen", value="set to alpha",variant='primary') |
| readalpha = gr.Button(elem_id="copytogen", value="read from alpha",variant='primary') |
| setbeta = gr.Button(elem_id="copytogen", value="set to beta",variant='primary') |
| readbeta = gr.Button(elem_id="copytogen", value="read from beta",variant='primary') |
| setx = gr.Button(elem_id="copytogen", value="set to X",variant='primary') |
| with gr.Row(): |
| weights_a = gr.Textbox(label="weights for alpha, base alpha,IN00,IN02,...IN11,M00,OUT00,...,OUT11",value = "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.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") |
| weights_b = gr.Textbox(label="weights,for beta, base beta,IN00,IN02,...IN11,M00,OUT00,...,OUT11",value = "0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2") |
| with gr.Row(): |
| base= gr.Slider(label="Base", minimum=0, maximum=1, step =0.01, value=0.5) |
| in00 = gr.Slider(label="IN00", minimum=0, maximum=1, step=0.01, value=0.5) |
| in01 = gr.Slider(label="IN01", minimum=0, maximum=1, step=0.01, value=0.5) |
| in02 = gr.Slider(label="IN02", minimum=0, maximum=1, step=0.01, value=0.5) |
| in03 = gr.Slider(label="IN03", minimum=0, maximum=1, step=0.01, value=0.5) |
| with gr.Row(): |
| in04 = gr.Slider(label="IN04", minimum=0, maximum=1, step=0.01, value=0.5) |
| in05 = gr.Slider(label="IN05", minimum=0, maximum=1, step=0.01, value=0.5) |
| in06 = gr.Slider(label="IN06", minimum=0, maximum=1, step=0.01, value=0.5) |
| in07 = gr.Slider(label="IN07", minimum=0, maximum=1, step=0.01, value=0.5) |
| in08 = gr.Slider(label="IN08", minimum=0, maximum=1, step=0.01, value=0.5) |
| in09 = gr.Slider(label="IN09", minimum=0, maximum=1, step=0.01, value=0.5) |
| with gr.Row(): |
| in10 = gr.Slider(label="IN10", minimum=0, maximum=1, step=0.01, value=0.5) |
| in11 = gr.Slider(label="IN11", minimum=0, maximum=1, step=0.01, value=0.5) |
| mi00 = gr.Slider(label="M00", minimum=0, maximum=1, step=0.01, value=0.5) |
| ou00 = gr.Slider(label="OUT00", minimum=0, maximum=1, step=0.01, value=0.5) |
| ou01 = gr.Slider(label="OUT01", minimum=0, maximum=1, step=0.01, value=0.5) |
| ou02 = gr.Slider(label="OUT02", minimum=0, maximum=1, step=0.01, value=0.5) |
| with gr.Row(): |
| ou03 = gr.Slider(label="OUT03", minimum=0, maximum=1, step=0.01, value=0.5) |
| ou04 = gr.Slider(label="OUT04", minimum=0, maximum=1, step=0.01, value=0.5) |
| ou05 = gr.Slider(label="OUT05", minimum=0, maximum=1, step=0.01, value=0.5) |
| ou06 = gr.Slider(label="OUT06", minimum=0, maximum=1, step=0.01, value=0.5) |
| ou07 = gr.Slider(label="OUT07", minimum=0, maximum=1, step=0.01, value=0.5) |
| ou08 = gr.Slider(label="OUT08", minimum=0, maximum=1, step=0.01, value=0.5) |
| with gr.Row(): |
| ou09 = gr.Slider(label="OUT09", minimum=0, maximum=1, step=0.01, value=0.5) |
| ou10 = gr.Slider(label="OUT10", minimum=0, maximum=1, step=0.01, value=0.5) |
| ou11 = gr.Slider(label="OUT11", minimum=0, maximum=1, step=0.01, value=0.5) |
| with gr.Tab("Weights Presets"): |
| with gr.Row(): |
| s_reloadtext = gr.Button(value="Reload Presets",variant='primary') |
| s_reloadtags = gr.Button(value="Reload Tags",variant='primary') |
| s_savetext = gr.Button(value="Save Presets",variant='primary') |
| s_openeditor = gr.Button(value="Open TextEditor",variant='primary') |
| weightstags= gr.Textbox(label="available",lines = 2,value=tagdicter(weights_presets),visible =True,interactive =True) |
| wpresets= gr.TextArea(label="",value=weights_presets,visible =True,interactive = True) |
|
|
| with gr.Tab("Reservation"): |
| with gr.Row(): |
| s_reserve = gr.Button(value="Reserve XY Plot",variant='primary') |
| s_reloadreserve = gr.Button(value="Reloat List",variant='primary') |
| s_startreserve = gr.Button(value="Start XY plot",variant='primary') |
| s_delreserve = gr.Button(value="Delete list(-1 for all)",variant='primary') |
| s_delnum = gr.Number(value=1, label="Delete num : ", interactive=True, visible = True,precision =0) |
| with gr.Row(): |
| numaframe = gr.Dataframe( |
| headers=["No.","status","xtype","xmenber", "ytype","ymenber","model A","model B","model C","alpha","beta","mode","use MBW","weights alpha","weights beta"], |
| row_count=5,) |
| |
| |
| |
| |
| |
| with gr.Row(): |
|
|
| currentcache = gr.Textbox(label="Current Cache") |
| loadcachelist = gr.Button(elem_id="model_merger_merge", value="Reload Cache List",variant='primary') |
| unloadmodel = gr.Button(value="unload model",variant='primary') |
|
|
|
|
| |
| |
| with gr.Tab("LoRA", elem_id="tab_lora"): |
| pluslora.on_ui_tabs() |
|
|
| with gr.Tab("History", elem_id="tab_history"): |
| |
| with gr.Row(): |
| load_history = gr.Button(value="load_history",variant='primary') |
| searchwrods = gr.Textbox(label="",lines=1,value="") |
| search = gr.Button(value="search") |
| searchmode = gr.Radio(label = "Search Mode",choices = ["or","and"], value = "or",type = "value") |
| with gr.Row(): |
| history = gr.Dataframe( |
| headers=["ID","Time","Name","Weights alpha","Weights beta","Model A","Model B","Model C","alpha","beta","Mode","use MBW","custum name","save setting","use ID"], |
| ) |
|
|
| with gr.Tab("Elements", elem_id="tab_deep"): |
| with gr.Row(): |
| smd_model_a = gr.Dropdown(sd_models.checkpoint_tiles(),elem_id="model_converter_model_name",label="Checkpoint A",interactive=True) |
| create_refresh_button(smd_model_a, sd_models.list_models,lambda: {"choices": sd_models.checkpoint_tiles()},"refresh_checkpoint_Z") |
| smd_loadkeys = gr.Button(value="load keys",variant='primary') |
| with gr.Row(): |
| keys = gr.Dataframe(headers=["No.","block","key"],) |
|
|
| with gr.Tab("Metadeta", elem_id="tab_metadata"): |
| with gr.Row(): |
| meta_model_a = gr.Dropdown(sd_models.checkpoint_tiles(),elem_id="model_converter_model_name",label="read metadata",interactive=True) |
| create_refresh_button(meta_model_a, sd_models.list_models,lambda: {"choices": sd_models.checkpoint_tiles()},"refresh_checkpoint_Z") |
| smd_loadmetadata = gr.Button(value="load keys",variant='primary') |
| with gr.Row(): |
| metadata = gr.TextArea() |
|
|
| smd_loadmetadata.click( |
| fn=loadmetadata, |
| inputs=[meta_model_a], |
| outputs=[metadata] |
| ) |
|
|
| smd_loadkeys.click( |
| fn=loadkeys, |
| inputs=[smd_model_a], |
| outputs=[keys] |
| ) |
|
|
| def unload(): |
| if shared.sd_model == None: return "already unloaded" |
| sd_hijack.model_hijack.undo_hijack(shared.sd_model) |
| shared.sd_model = None |
| gc.collect() |
| devices.torch_gc() |
| return "model unloaded" |
|
|
| unloadmodel.click(fn=unload,outputs=[submit_result]) |
|
|
| load_history.click(fn=load_historyf,outputs=[history ]) |
|
|
| msettings=[weights_a,weights_b,model_a,model_b,model_c,base_alpha,base_beta,mode,calcmode,useblocks,custom_name,save_sets,id_sets,wpresets,deep,tensor] |
| imagegal = [mgallery,mgeninfo,mhtmlinfo,mhtmllog] |
| xysettings=[x_type,xgrid,y_type,ygrid,esettings] |
|
|
| s_reverse.click(fn = reversparams, |
| inputs =mergeid, |
| outputs = [submit_result,*msettings[0:8],*msettings[9:13],deep,calcmode] |
| ) |
|
|
| merge.click( |
| fn=smergegen, |
| inputs=[*msettings,esettings1,*gensets.txt2img_preview_params,*hiresfix,batch_size,currentmodel,dfalse], |
| outputs=[submit_result,currentmodel] |
| ) |
|
|
| mergeandgen.click( |
| fn=smergegen, |
| inputs=[*msettings,esettings1,*gensets.txt2img_preview_params,*hiresfix,batch_size,currentmodel,dtrue], |
| outputs=[submit_result,currentmodel,*imagegal] |
| ) |
|
|
| gen.click( |
| fn=simggen, |
| inputs=[*gensets.txt2img_preview_params,*hiresfix,batch_size,currentmodel,id_sets], |
| outputs=[*imagegal], |
| ) |
|
|
| s_reserve.click( |
| fn=numaker, |
| inputs=[*xysettings,*msettings,*gensets.txt2img_preview_params,*hiresfix,batch_size], |
| outputs=[numaframe] |
| ) |
|
|
| s_reserve1.click( |
| fn=numaker, |
| inputs=[*xysettings,*msettings,*gensets.txt2img_preview_params,*hiresfix,batch_size], |
| outputs=[numaframe] |
| ) |
|
|
| gengrid.click( |
| fn=numanager, |
| inputs=[dtrue,*xysettings,*msettings,*gensets.txt2img_preview_params,*hiresfix,batch_size], |
| outputs=[submit_result,currentmodel,*imagegal], |
| ) |
|
|
| s_startreserve.click( |
| fn=numanager, |
| inputs=[dfalse,*xysettings,*msettings,*gensets.txt2img_preview_params,*hiresfix,batch_size], |
| outputs=[submit_result,currentmodel,*imagegal], |
| ) |
|
|
| search.click(fn = searchhistory,inputs=[searchwrods,searchmode],outputs=[history]) |
|
|
| s_reloadreserve.click(fn=nulister,inputs=[dfalse],outputs=[numaframe]) |
| s_delreserve.click(fn=nulister,inputs=[s_delnum],outputs=[numaframe]) |
| loadcachelist.click(fn=load_cachelist,inputs=[],outputs=[currentcache]) |
| addtox.click(fn=lambda x:gr.Textbox.update(value = x),inputs=[inputer],outputs=[xgrid]) |
| addtoy.click(fn=lambda x:gr.Textbox.update(value = x),inputs=[inputer],outputs=[ygrid]) |
|
|
| stopgrid.click(fn=freezetime) |
| stopmerge.click(fn=freezemtime) |
|
|
| checkpoints.change(fn=lambda x:",".join(x),inputs=[checkpoints],outputs=[inputer]) |
| blockids.change(fn=lambda x:" ".join(x),inputs=[blockids],outputs=[inputer]) |
| calcmodes.change(fn=lambda x:",".join(x),inputs=[calcmodes],outputs=[inputer]) |
|
|
| menbers = [base,in00,in01,in02,in03,in04,in05,in06,in07,in08,in09,in10,in11,mi00,ou00,ou01,ou02,ou03,ou04,ou05,ou06,ou07,ou08,ou09,ou10,ou11] |
|
|
| setalpha.click(fn=slider2text,inputs=menbers,outputs=[weights_a]) |
| setbeta.click(fn=slider2text,inputs=menbers,outputs=[weights_b]) |
| setx.click(fn=add_to_seq,inputs=[xgrid,weights_a],outputs=[xgrid]) |
|
|
| readalpha.click(fn=text2slider,inputs=weights_a,outputs=menbers) |
| readbeta.click(fn=text2slider,inputs=weights_b,outputs=menbers) |
|
|
| x_type.change(fn=showxy,inputs=[x_type,y_type], outputs=[row_blockids,row_checkpoints,row_inputers,ygrid,row_esets,row_calcmode]) |
| y_type.change(fn=showxy,inputs=[x_type,y_type], outputs=[row_blockids,row_checkpoints,row_inputers,ygrid,row_esets,row_calcmode]) |
| x_randseednum.change(fn=makerand,inputs=[x_randseednum],outputs=[xgrid]) |
|
|
| import subprocess |
| def openeditors(): |
| subprocess.Popen(['start', filepath], shell=True) |
|
|
| def reloadpresets(): |
| try: |
| with open(filepath) as f: |
| return f.read() |
| except OSError as e: |
| pass |
|
|
| def savepresets(text): |
| with open(filepath,mode = 'w') as f: |
| f.write(text) |
|
|
| s_reloadtext.click(fn=reloadpresets,inputs=[],outputs=[wpresets]) |
| s_reloadtags.click(fn=tagdicter,inputs=[wpresets],outputs=[weightstags]) |
| s_savetext.click(fn=savepresets,inputs=[wpresets],outputs=[]) |
| s_openeditor.click(fn=openeditors,inputs=[],outputs=[]) |
|
|
| return (supermergerui, "SuperMerger", "supermerger"), |
|
|
| msearch = [] |
| mlist=[] |
|
|
| def loadmetadata(model): |
| import json |
| checkpoint_info = sd_models.get_closet_checkpoint_match(model) |
| if ".safetensors" not in checkpoint_info.filename: return "no metadata(not safetensors)" |
| sdict = sd_models.read_metadata_from_safetensors(checkpoint_info.filename) |
| if sdict == {}: return "no metadata" |
| return json.dumps(sdict,indent=4) |
|
|
| def load_historyf(): |
| filepath = os.path.join(path_root,"mergehistory.csv") |
| global mlist,msearch |
| msearch = [] |
| mlist=[] |
| try: |
| with open(filepath, 'r') as f: |
| reader = csv.reader(f) |
| mlist = [raw for raw in reader] |
| mlist = mlist[1:] |
| for m in mlist: |
| msearch.append(" ".join(m)) |
| maxlen = len(mlist[-1][0]) |
| for i,m in enumerate(mlist): |
| mlist[i][0] = mlist[i][0].zfill(maxlen) |
| return mlist |
| except: |
| return [["no data","",""],] |
|
|
| def searchhistory(words,searchmode): |
| outs =[] |
| ando = "and" in searchmode |
| words = words.split(" ") if " " in words else [words] |
| for i, m in enumerate(msearch): |
| hit = ando |
| for w in words: |
| if ando: |
| if w not in m:hit = False |
| else: |
| if w in m:hit = True |
| print(i,len(mlist)) |
| if hit :outs.append(mlist[i]) |
|
|
| if outs == []:return [["no result","",""],] |
| return outs |
|
|
| |
|
|
| def reversparams(id): |
| def selectfromhash(hash): |
| for model in sd_models.checkpoint_tiles(): |
| if hash in model: |
| return model |
| return "" |
| try: |
| idsets = rwmergelog(id = id) |
| except: |
| return [gr.update(value = "ERROR: history file could not open"),*[gr.update() for x in range(14)]] |
| if type(idsets) == str: |
| print("ERROR") |
| return [gr.update(value = idsets),*[gr.update() for x in range(14)]] |
| if idsets[0] == "ID":return [gr.update(value ="ERROR: no history"),*[gr.update() for x in range(14)]] |
| mgs = idsets[3:] |
| if mgs[0] == "":mgs[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.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" |
| if mgs[1] == "":mgs[1] = "0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2,0.2" |
| mgs[2] = selectfromhash(mgs[2]) if len(mgs[2]) > 5 else "" |
| mgs[3] = selectfromhash(mgs[3]) if len(mgs[3]) > 5 else "" |
| mgs[4] = selectfromhash(mgs[4]) if len(mgs[4]) > 5 else "" |
| mgs[8] = True if mgs[8] =="True" else False |
| mgs[10] = mgs[10].replace("[","").replace("]","").replace("'", "") |
| mgs[10] = [x.strip() for x in mgs[10].split(",")] |
| mgs[11] = mgs[11].replace("[","").replace("]","").replace("'", "") |
| mgs[11] = [x.strip() for x in mgs[11].split(",")] |
| while len(mgs) < 14: |
| mgs.append("") |
| mgs[13] = "normal" if mgs[13] == "" else mgs[13] |
| return [gr.update(value = "setting loaded") ,*[gr.update(value = x) for x in mgs[0:14]]] |
|
|
| def add_to_seq(seq,maker): |
| return gr.Textbox.update(value = maker if seq=="" else seq+"\r\n"+maker) |
|
|
| def load_cachelist(): |
| text = "" |
| for x in checkpoints_loaded.keys(): |
| text = text +"\r\n"+ x.model_name |
| return text.replace("\r\n","",1) |
|
|
| def makerand(num): |
| text = "" |
| for x in range(int(num)): |
| text = text +"-1," |
| text = text[:-1] |
| return text |
|
|
| |
| def showxy(x,y): |
| flags =[False]*6 |
| t = TYPESEG |
| txy = t[x] + t[y] |
| if "model" in txy : flags[1] = flags[2] = True |
| if "pinpoint" in txy : flags[0] = flags[2] = True |
| if "effective" in txy or "element" in txy : flags[4] = True |
| if "calcmode" in txy : flags[5] = True |
| if not "none" in t[y] : flags[3] = flags[2] = True |
| return [gr.update(visible = x) for x in flags] |
|
|
| def text2slider(text): |
| vals = [t.strip() for t in text.split(",")] |
| return [gr.update(value = float(v)) for v in vals] |
|
|
| def slider2text(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z): |
| numbers = [a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z] |
| numbers = [str(x) for x in numbers] |
| return gr.update(value = ",".join(numbers) ) |
|
|
| def tagdicter(presets): |
| presets=presets.splitlines() |
| wdict={} |
| for l in presets: |
| w=[] |
| if ":" in l : |
| key = l.split(":",1)[0] |
| w = l.split(":",1)[1] |
| if "\t" in l: |
| key = l.split("\t",1)[0] |
| w = l.split("\t",1)[1] |
| if len([w for w in w.split(",")]) == 26: |
| wdict[key.strip()]=w |
| return ",".join(list(wdict.keys())) |
|
|
| def loadkeys(model_a): |
| checkpoint_info = sd_models.get_closet_checkpoint_match(model_a) |
| sd = sd_models.read_state_dict(checkpoint_info.filename,"cpu") |
| keys = [] |
| for i, key in enumerate(sd.keys()): |
| re_inp = re.compile(r'\.input_blocks\.(\d+)\.') |
| re_mid = re.compile(r'\.middle_block\.(\d+)\.') |
| re_out = re.compile(r'\.output_blocks\.(\d+)\.') |
|
|
| weight_index = -1 |
| blockid=["BASE","IN00","IN01","IN02","IN03","IN04","IN05","IN06","IN07","IN08","IN09","IN10","IN11","M00","OUT00","OUT01","OUT02","OUT03","OUT04","OUT05","OUT06","OUT07","OUT08","OUT09","OUT10","OUT11","Not Merge"] |
|
|
| NUM_INPUT_BLOCKS = 12 |
| NUM_MID_BLOCK = 1 |
| NUM_OUTPUT_BLOCKS = 12 |
| NUM_TOTAL_BLOCKS = NUM_INPUT_BLOCKS + NUM_MID_BLOCK + NUM_OUTPUT_BLOCKS |
|
|
| if 'time_embed' in key: |
| weight_index = -2 |
| elif '.out.' in key: |
| weight_index = NUM_TOTAL_BLOCKS - 1 |
| else: |
| m = re_inp.search(key) |
| if m: |
| inp_idx = int(m.groups()[0]) |
| weight_index = inp_idx |
| else: |
| m = re_mid.search(key) |
| if m: |
| weight_index = NUM_INPUT_BLOCKS |
| else: |
| m = re_out.search(key) |
| if m: |
| out_idx = int(m.groups()[0]) |
| weight_index = NUM_INPUT_BLOCKS + NUM_MID_BLOCK + out_idx |
| keys.append([i,blockid[weight_index+1],key]) |
| return keys |
|
|
| script_callbacks.on_ui_tabs(on_ui_tabs) |
| script_callbacks.on_ui_train_tabs(on_ui_train_tabs) |
|
|
