| import datetime | |
| import html | |
| import re | |
| import gradio as gr | |
| from modules.ui_extra_networks_user_metadata import UserMetadataEditor | |
| re_word = re.compile(r"[-_\w']+") | |
| re_comma = re.compile(r" *, *") | |
| def is_non_comma_tagset(tags): | |
| average_tag_length = sum(len(x) for x in tags.keys()) / len(tags) | |
| return average_tag_length >= 16 | |
| def build_tags(metadata): | |
| tags = {} | |
| for _, tags_dict in metadata.get("ss_tag_frequency", {}).items(): | |
| for tag, tag_count in tags_dict.items(): | |
| tag = tag.strip() | |
| tags[tag] = tags.get(tag, 0) + int(tag_count) | |
| if tags and is_non_comma_tagset(tags): | |
| new_tags = {} | |
| for text, text_count in tags.items(): | |
| for word in re.findall(re_word, text): | |
| if len(word) < 3: | |
| continue | |
| new_tags[word] = new_tags.get(word, 0) + text_count | |
| tags = new_tags | |
| ordered_tags = sorted(tags.keys(), key=tags.get, reverse=True) | |
| return [(tag, tags[tag]) for tag in ordered_tags] | |
| class LoraUserMetadataEditor(UserMetadataEditor): | |
| def __init__(self, ui, tabname, page): | |
| super().__init__(ui, tabname, page) | |
| self.select_sd_version = None | |
| self.taginfo = None | |
| self.edit_activation_text = None | |
| self.slider_preferred_weight = None | |
| self.edit_notes = None | |
| def save_lora_user_metadata( | |
| self, | |
| name: str, | |
| desc: str, | |
| sd_version: str, | |
| activation_text: str, | |
| preferred_weight: float, | |
| negative_text: str, | |
| notes: str, | |
| ): | |
| user_metadata = self.get_user_metadata(name) | |
| user_metadata["description"] = desc | |
| user_metadata["sd version"] = sd_version | |
| user_metadata["activation text"] = activation_text | |
| user_metadata["preferred weight"] = preferred_weight | |
| user_metadata["negative text"] = negative_text | |
| user_metadata["notes"] = notes | |
| self.write_user_metadata(name, user_metadata) | |
| def get_metadata_table(self, name): | |
| table = super().get_metadata_table(name) | |
| item = self.page.items.get(name, {}) | |
| metadata = item.get("metadata") or {} | |
| keys = { | |
| "ss_output_name": "Output name:", | |
| "ss_sd_model_name": "Model:", | |
| "ss_clip_skip": "Clip skip:", | |
| "ss_network_module": "Kohya module:", | |
| } | |
| for key, label in keys.items(): | |
| value = metadata.get(key, None) | |
| if value is not None and str(value) != "None": | |
| table.append((label, html.escape(value))) | |
| ss_training_started_at = metadata.get("ss_training_started_at") | |
| if ss_training_started_at: | |
| table.append( | |
| ( | |
| "Date trained:", | |
| datetime.datetime.fromtimestamp(float(ss_training_started_at)).strftime("%Y-%m-%d %H:%M"), | |
| ) | |
| ) | |
| ss_bucket_info = metadata.get("ss_bucket_info") | |
| if ss_bucket_info and "buckets" in ss_bucket_info: | |
| resolutions = {} | |
| for _, bucket in ss_bucket_info["buckets"].items(): | |
| resolution = bucket["resolution"] | |
| resolution = f"{resolution[1]}x{resolution[0]}" | |
| resolutions[resolution] = resolutions.get(resolution, 0) + int(bucket["count"]) | |
| resolutions_list = sorted(resolutions.keys(), key=resolutions.get, reverse=True) | |
| resolutions_text = html.escape(", ".join(resolutions_list[0:4])) | |
| if len(resolutions) > 4: | |
| resolutions_text += ", ..." | |
| resolutions_text = f"<span title='{html.escape(', '.join(resolutions_list))}'>{resolutions_text}</span>" | |
| table.append( | |
| ( | |
| "Resolutions:" if len(resolutions_list) > 1 else "Resolution:", | |
| resolutions_text, | |
| ) | |
| ) | |
| image_count = 0 | |
| for _, params in metadata.get("ss_dataset_dirs", {}).items(): | |
| image_count += int(params.get("img_count", 0)) | |
| if image_count: | |
| table.append(("Dataset size:", image_count)) | |
| return table | |
| def put_values_into_components(self, name): | |
| user_metadata = self.get_user_metadata(name) | |
| values = super().put_values_into_components(name) | |
| item = self.page.items.get(name, {}) | |
| metadata = item.get("metadata") or {} | |
| tags = build_tags(metadata) | |
| gradio_tags = [(tag, str(count)) for tag, count in tags[0:24]] | |
| return [ | |
| *values[0:5], | |
| gr.update(value=item.get("sd_version", "Unknown")), | |
| gr.HighlightedText.update(value=gradio_tags, visible=True if tags else False), | |
| user_metadata.get("activation text", ""), | |
| float(user_metadata.get("preferred weight", 0.0)), | |
| user_metadata.get("negative text", ""), | |
| ] | |
| def create_extra_default_items_in_left_column(self): | |
| self.select_sd_version = gr.Dropdown( | |
| choices=("SD1", "SDXL", "Unknown"), | |
| value="Unknown", | |
| label="Stable Diffusion Version", | |
| interactive=True, | |
| ) | |
| def create_editor(self): | |
| self.create_default_editor_elems() | |
| self.taginfo = gr.HighlightedText(label="Training dataset tags") | |
| self.edit_activation_text = gr.Textbox(label="Positive Prompt", info="Will be added to the prompt after the LoRA syntax", lines=2) | |
| self.edit_negative_text = gr.Textbox(label="Negative Prompt", info="Will be added to the negative prompt", lines=2) | |
| self.slider_preferred_weight = gr.Slider( | |
| label="Preferred weight", | |
| info="Set to 0 to use the default set in Settings", | |
| minimum=0.0, | |
| maximum=2.0, | |
| step=0.1, | |
| ) | |
| self.edit_notes = gr.TextArea(label="Notes", lines=4) | |
| def select_tag(activation_text, evt: gr.SelectData): | |
| tag = evt.value[0] | |
| words = re.split(re_comma, activation_text) | |
| if tag in words: | |
| words = [x for x in words if x != tag and x.strip()] | |
| return ", ".join(words) | |
| return activation_text + ", " + tag if activation_text else tag | |
| self.taginfo.select( | |
| fn=select_tag, | |
| inputs=[self.edit_activation_text], | |
| outputs=[self.edit_activation_text], | |
| show_progress=False, | |
| ) | |
| self.create_default_buttons() | |
| viewed_components = [ | |
| self.edit_name, | |
| self.edit_description, | |
| self.html_filedata, | |
| self.html_preview, | |
| self.edit_notes, | |
| self.select_sd_version, | |
| self.taginfo, | |
| self.edit_activation_text, | |
| self.slider_preferred_weight, | |
| self.edit_negative_text, | |
| ] | |
| self.button_edit.click( | |
| fn=self.put_values_into_components, | |
| inputs=[self.edit_name_input], | |
| outputs=viewed_components, | |
| ).then(fn=lambda: gr.update(visible=True), inputs=[], outputs=[self.box]) | |
| edited_components = [ | |
| self.edit_description, | |
| self.select_sd_version, | |
| self.edit_activation_text, | |
| self.slider_preferred_weight, | |
| self.edit_negative_text, | |
| self.edit_notes, | |
| ] | |
| self.setup_save_handler(self.button_save, self.save_lora_user_metadata, edited_components) | |