Upload 13 files

mikazuki/app.py

@@ -0,0 +1,113 @@
+import json
+import os
+import subprocess
+import sys
+from datetime import datetime
+from threading import Lock
+
+import starlette.responses as starlette_responses
+from fastapi import BackgroundTasks, FastAPI, Request
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+
+import toml
+
+from mikazuki.models import TaggerInterrogateRequest
+from mikazuki.tagger.interrogator import WaifuDiffusionInterrogator, on_interrogate
+
+app = FastAPI()
+lock = Lock()
+interrogator = WaifuDiffusionInterrogator('wd14-convnextv2-v2', repo_id='SmilingWolf/wd-v1-4-convnextv2-tagger-v2', revision='v2.0')
+
+# fix mimetype error in some fucking systems
+_origin_guess_type = starlette_responses.guess_type
+
+
+def _hooked_guess_type(*args, **kwargs):
+    url = args[0]
+    r = _origin_guess_type(*args, **kwargs)
+    if url.endswith(".js"):
+        r = ("application/javascript", None)
+    elif url.endswith(".css"):
+        r = ("text/css", None)
+    return r
+
+
+starlette_responses.guess_type = _hooked_guess_type
+
+
+def run_train(toml_path: str):
+    print(f"Training started with config file / 训练开始，使用配置文件: {toml_path}")
+    args = [
+        sys.executable, "-m", "accelerate.commands.launch", "--num_cpu_threads_per_process", "8",
+        "./sd-scripts/train_network.py",
+        "--config_file", toml_path,
+    ]
+    try:
+        result = subprocess.run(args, env=os.environ)
+        if result.returncode != 0:
+            print(f"Training failed / 训练失败")
+        else:
+            print(f"Training finished / 训练完成")
+    except Exception as e:
+        print(f"An error occurred when training / 创建训练进程时出现致命错误: {e}")
+    finally:
+        lock.release()
+
+
+@app.middleware("http")
+async def add_cache_control_header(request, call_next):
+    response = await call_next(request)
+    response.headers["Cache-Control"] = "max-age=0"
+    return response
+
+
+@app.post("/api/run")
+async def create_toml_file(request: Request, background_tasks: BackgroundTasks):
+    acquired = lock.acquire(blocking=False)
+
+    if not acquired:
+        print("Training is already running / 已有正在进行的训练")
+        return {"status": "fail", "detail": "Training is already running"}
+
+    timestamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+    toml_file = os.path.join(os.getcwd(), f"toml", "autosave", f"{timestamp}.toml")
+    toml_data = await request.body()
+    j = json.loads(toml_data.decode("utf-8"))
+    with open(toml_file, "w") as f:
+        f.write(toml.dumps(j))
+    background_tasks.add_task(run_train, toml_file)
+    return {"status": "success"}
+
+
+@app.post("/api/interrogate")
+async def run_interrogate(req: TaggerInterrogateRequest, background_tasks: BackgroundTasks):
+    background_tasks.add_task(on_interrogate,
+                              image=None,
+                              batch_input_glob=req.path,
+                              batch_input_recursive=False,
+                              batch_output_dir="",
+                              batch_output_filename_format="[name].[output_extension]",
+                              batch_output_action_on_conflict=req.batch_output_action_on_conflict,
+                              batch_remove_duplicated_tag=True,
+                              batch_output_save_json=False,
+                              interrogator=interrogator,
+                              threshold=req.threshold,
+                              additional_tags=req.additional_tags,
+                              exclude_tags=req.exclude_tags,
+                              sort_by_alphabetical_order=False,
+                              add_confident_as_weight=False,
+                              replace_underscore=req.replace_underscore,
+                              replace_underscore_excludes=req.replace_underscore_excludes,
+                              escape_tag=req.escape_tag,
+                              unload_model_after_running=True
+                              )
+    return {"status": "success"}
+
+
+@app.get("/")
+async def index():
+    return FileResponse("./frontend/dist/index.html")
+
+
+app.mount("/", StaticFiles(directory="frontend/dist"), name="static")

mikazuki/models.py

@@ -0,0 +1,18 @@
+from pydantic import BaseModel, Field
+
+
+class TaggerInterrogateRequest(BaseModel):
+    path: str
+    threshold: float = Field(
+        default=0.35,
+        ge=0,
+        le=1
+    )
+    additional_tags: str = ""
+    exclude_tags: str = ""
+    escape_tag: bool = True
+    batch_output_action_on_conflict: str = "ignore"
+    replace_underscore: bool = True
+    replace_underscore_excludes: str = Field(
+        default="0_0, (o)_(o), +_+, +_-, ._., <o>_<o>, <|>_<|>, =_=, >_<, 3_3, 6_9, >_o, @_@, ^_^, o_o, u_u, x_x, |_|, ||_||"
+    )

mikazuki/tagger/dbimutils.py

@@ -0,0 +1,54 @@
+# DanBooru IMage Utility functions
+
+import cv2
+import numpy as np
+from PIL import Image
+
+
+def smart_imread(img, flag=cv2.IMREAD_UNCHANGED):
+    if img.endswith(".gif"):
+        img = Image.open(img)
+        img = img.convert("RGB")
+        img = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
+    else:
+        img = cv2.imread(img, flag)
+    return img
+
+
+def smart_24bit(img):
+    if img.dtype is np.dtype(np.uint16):
+        img = (img / 257).astype(np.uint8)
+
+    if len(img.shape) == 2:
+        img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
+    elif img.shape[2] == 4:
+        trans_mask = img[:, :, 3] == 0
+        img[trans_mask] = [255, 255, 255, 255]
+        img = cv2.cvtColor(img, cv2.COLOR_BGRA2BGR)
+    return img
+
+
+def make_square(img, target_size):
+    old_size = img.shape[:2]
+    desired_size = max(old_size)
+    desired_size = max(desired_size, target_size)
+
+    delta_w = desired_size - old_size[1]
+    delta_h = desired_size - old_size[0]
+    top, bottom = delta_h // 2, delta_h - (delta_h // 2)
+    left, right = delta_w // 2, delta_w - (delta_w // 2)
+
+    color = [255, 255, 255]
+    new_im = cv2.copyMakeBorder(
+        img, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color
+    )
+    return new_im
+
+
+def smart_resize(img, size):
+    # Assumes the image has already gone through make_square
+    if img.shape[0] > size:
+        img = cv2.resize(img, (size, size), interpolation=cv2.INTER_AREA)
+    elif img.shape[0] < size:
+        img = cv2.resize(img, (size, size), interpolation=cv2.INTER_CUBIC)
+    return img

mikazuki/tagger/format.py

@@ -0,0 +1,46 @@
+import re
+import hashlib
+
+from typing import Dict, Callable, NamedTuple
+from pathlib import Path
+
+
+class Info(NamedTuple):
+    path: Path
+    output_ext: str
+
+
+def hash(i: Info, algo='sha1') -> str:
+    try:
+        hash = hashlib.new(algo)
+    except ImportError:
+        raise ValueError(f"'{algo}' is invalid hash algorithm")
+
+    # TODO: is okay to hash large image?
+    with open(i.path, 'rb') as file:
+        hash.update(file.read())
+
+    return hash.hexdigest()
+
+
+pattern = re.compile(r'\[([\w:]+)\]')
+
+# all function must returns string or raise TypeError or ValueError
+# other errors will cause the extension error
+available_formats: Dict[str, Callable] = {
+    'name': lambda i: i.path.stem,
+    'extension': lambda i: i.path.suffix[1:],
+    'hash': hash,
+
+    'output_extension': lambda i: i.output_ext
+}
+
+
+def format(match: re.Match, info: Info) -> str:
+    matches = match[1].split(':')
+    name, args = matches[0], matches[1:]
+
+    if name not in available_formats:
+        return match[0]
+
+    return available_formats[name](info, *args)

mikazuki/tagger/interrogator.py

@@ -0,0 +1,366 @@
+# from https://github.com/toriato/stable-diffusion-webui-wd14-tagger
+import json
+import os
+import re
+from collections import OrderedDict
+from glob import glob
+from pathlib import Path
+from typing import Dict, List, Tuple
+
+import numpy as np
+import pandas as pd
+from PIL import Image
+from PIL import UnidentifiedImageError
+from huggingface_hub import hf_hub_download
+
+from mikazuki.tagger import dbimutils, format
+
+tag_escape_pattern = re.compile(r'([\\()])')
+
+
+class Interrogator:
+    @staticmethod
+    def postprocess_tags(
+            tags: Dict[str, float],
+
+            threshold=0.35,
+            additional_tags: List[str] = [],
+            exclude_tags: List[str] = [],
+            sort_by_alphabetical_order=False,
+            add_confident_as_weight=False,
+            replace_underscore=False,
+            replace_underscore_excludes: List[str] = [],
+            escape_tag=False
+    ) -> Dict[str, float]:
+        for t in additional_tags:
+            tags[t] = 1.0
+
+        # those lines are totally not "pythonic" but looks better to me
+        tags = {
+            t: c
+
+            # sort by tag name or confident
+            for t, c in sorted(
+                tags.items(),
+                key=lambda i: i[0 if sort_by_alphabetical_order else 1],
+                reverse=not sort_by_alphabetical_order
+            )
+
+            # filter tags
+            if (
+                    c >= threshold
+                    and t not in exclude_tags
+            )
+        }
+
+        new_tags = []
+        for tag in list(tags):
+            new_tag = tag
+
+            if replace_underscore and tag not in replace_underscore_excludes:
+                new_tag = new_tag.replace('_', ' ')
+
+            if escape_tag:
+                new_tag = tag_escape_pattern.sub(r'\\\1', new_tag)
+
+            if add_confident_as_weight:
+                new_tag = f'({new_tag}:{tags[tag]})'
+
+            new_tags.append((new_tag, tags[tag]))
+        tags = dict(new_tags)
+
+        return tags
+
+    def __init__(self, name: str) -> None:
+        self.name = name
+
+    def load(self):
+        raise NotImplementedError()
+
+    def unload(self) -> bool:
+        unloaded = False
+
+        if hasattr(self, 'model') and self.model is not None:
+            del self.model
+            unloaded = True
+            print(f'Unloaded {self.name}')
+
+        if hasattr(self, 'tags'):
+            del self.tags
+
+        return unloaded
+
+    def interrogate(
+            self,
+            image: Image
+    ) -> Tuple[
+        Dict[str, float],  # rating confidents
+        Dict[str, float]  # tag confidents
+    ]:
+        raise NotImplementedError()
+
+
+class WaifuDiffusionInterrogator(Interrogator):
+    def __init__(
+            self,
+            name: str,
+            model_path='model.onnx',
+            tags_path='selected_tags.csv',
+            **kwargs
+    ) -> None:
+        super().__init__(name)
+        self.model_path = model_path
+        self.tags_path = tags_path
+        self.kwargs = kwargs
+
+    def download(self) -> Tuple[os.PathLike, os.PathLike]:
+        print(f"Loading {self.name} model file from {self.kwargs['repo_id']}")
+
+        model_path = Path(hf_hub_download(
+            **self.kwargs, filename=self.model_path))
+        tags_path = Path(hf_hub_download(
+            **self.kwargs, filename=self.tags_path))
+        return model_path, tags_path
+
+    def load(self) -> None:
+        model_path, tags_path = self.download()
+
+        # only one of these packages should be installed at a time in any one environment
+        # https://onnxruntime.ai/docs/get-started/with-python.html#install-onnx-runtime
+        # TODO: remove old package when the environment changes?
+        from mikazuki.utils import is_installed, run_pip
+        if not is_installed('onnxruntime'):
+            package = os.environ.get(
+                'ONNXRUNTIME_PACKAGE',
+                'onnxruntime-gpu'
+            )
+
+            run_pip(f'install {package}', 'onnxruntime')
+
+        # Load torch to load cuda libs built in torch for onnxruntime, do not delete this.
+        import torch
+        from onnxruntime import InferenceSession
+
+        # https://onnxruntime.ai/docs/execution-providers/
+        # https://github.com/toriato/stable-diffusion-webui-wd14-tagger/commit/e4ec460122cf674bbf984df30cdb10b4370c1224#r92654958
+        providers = ['CUDAExecutionProvider', 'CPUExecutionProvider']
+
+        self.model = InferenceSession(str(model_path), providers=providers)
+
+        print(f'Loaded {self.name} model from {model_path}')
+
+        self.tags = pd.read_csv(tags_path)
+
+    def interrogate(
+            self,
+            image: Image
+    ) -> Tuple[
+        Dict[str, float],  # rating confidents
+        Dict[str, float]  # tag confidents
+    ]:
+        # init model
+        if not hasattr(self, 'model') or self.model is None:
+            self.load()
+
+        # code for converting the image and running the model is taken from the link below
+        # thanks, SmilingWolf!
+        # https://huggingface.co/spaces/SmilingWolf/wd-v1-4-tags/blob/main/app.py
+
+        # convert an image to fit the model
+        _, height, _, _ = self.model.get_inputs()[0].shape
+
+        # alpha to white
+        image = image.convert('RGBA')
+        new_image = Image.new('RGBA', image.size, 'WHITE')
+        new_image.paste(image, mask=image)
+        image = new_image.convert('RGB')
+        image = np.asarray(image)
+
+        # PIL RGB to OpenCV BGR
+        image = image[:, :, ::-1]
+
+        image = dbimutils.make_square(image, height)
+        image = dbimutils.smart_resize(image, height)
+        image = image.astype(np.float32)
+        image = np.expand_dims(image, 0)
+
+        # evaluate model
+        input_name = self.model.get_inputs()[0].name
+        label_name = self.model.get_outputs()[0].name
+        confidents = self.model.run([label_name], {input_name: image})[0]
+
+        tags = self.tags[:][['name']]
+        tags['confidents'] = confidents[0]
+
+        # first 4 items are for rating (general, sensitive, questionable, explicit)
+        ratings = dict(tags[:4].values)
+
+        # rest are regular tags
+        tags = dict(tags[4:].values)
+
+        return ratings, tags
+
+
+def split_str(s: str, separator=',') -> List[str]:
+    return [x.strip() for x in s.split(separator) if x]
+
+
+def on_interrogate(
+        image: Image,
+        batch_input_glob: str,
+        batch_input_recursive: bool,
+        batch_output_dir: str,
+        batch_output_filename_format: str,
+        batch_output_action_on_conflict: str,
+        batch_remove_duplicated_tag: bool,
+        batch_output_save_json: bool,
+
+        interrogator: Interrogator,
+        threshold: float,
+        additional_tags: str,
+        exclude_tags: str,
+        sort_by_alphabetical_order: bool,
+        add_confident_as_weight: bool,
+        replace_underscore: bool,
+        replace_underscore_excludes: str,
+        escape_tag: bool,
+
+        unload_model_after_running: bool
+):
+
+    postprocess_opts = (
+        threshold,
+        split_str(additional_tags),
+        split_str(exclude_tags),
+        sort_by_alphabetical_order,
+        add_confident_as_weight,
+        replace_underscore,
+        split_str(replace_underscore_excludes),
+        escape_tag
+    )
+
+    # batch process
+    batch_input_glob = batch_input_glob.strip()
+    batch_output_dir = batch_output_dir.strip()
+    batch_output_filename_format = batch_output_filename_format.strip()
+
+    if batch_input_glob != '':
+        # if there is no glob pattern, insert it automatically
+        if not batch_input_glob.endswith('*'):
+            if not batch_input_glob.endswith(os.sep):
+                batch_input_glob += os.sep
+            batch_input_glob += '*'
+
+        # get root directory of input glob pattern
+        base_dir = batch_input_glob.replace('?', '*')
+        base_dir = base_dir.split(os.sep + '*').pop(0)
+
+        # check the input directory path
+        if not os.path.isdir(base_dir):
+            print("input path is not a directory / 输入的路径不是文件夹，终止识别")
+            return 'input path is not a directory'
+
+        # this line is moved here because some reason
+        # PIL.Image.registered_extensions() returns only PNG if you call too early
+        supported_extensions = [
+            e
+            for e, f in Image.registered_extensions().items()
+            if f in Image.OPEN
+        ]
+
+        paths = [
+            Path(p)
+            for p in glob(batch_input_glob, recursive=batch_input_recursive)
+            if '.' + p.split('.').pop().lower() in supported_extensions
+        ]
+
+        print(f'found {len(paths)} image(s)')
+
+        for path in paths:
+            try:
+                image = Image.open(path)
+            except UnidentifiedImageError:
+                # just in case, user has mysterious file...
+                print(f'${path} is not supported image type')
+                continue
+
+            # guess the output path
+            base_dir_last = Path(base_dir).parts[-1]
+            base_dir_last_idx = path.parts.index(base_dir_last)
+            output_dir = Path(
+                batch_output_dir) if batch_output_dir else Path(base_dir)
+            output_dir = output_dir.joinpath(
+                *path.parts[base_dir_last_idx + 1:]).parent
+
+            output_dir.mkdir(0o777, True, True)
+
+            # format output filename
+            format_info = format.Info(path, 'txt')
+
+            try:
+                formatted_output_filename = format.pattern.sub(
+                    lambda m: format.format(m, format_info),
+                    batch_output_filename_format
+                )
+            except (TypeError, ValueError) as error:
+                return str(error)
+
+            output_path = output_dir.joinpath(
+                formatted_output_filename
+            )
+
+            output = []
+
+            if output_path.is_file():
+                output.append(output_path.read_text(errors='ignore').strip())
+
+                if batch_output_action_on_conflict == 'ignore':
+                    print(f'skipping {path}')
+                    continue
+
+            ratings, tags = interrogator.interrogate(image)
+            processed_tags = Interrogator.postprocess_tags(
+                tags,
+                *postprocess_opts
+            )
+
+            # TODO: switch for less print
+            print(
+                f'found {len(processed_tags)} tags out of {len(tags)} from {path}'
+            )
+
+            plain_tags = ', '.join(processed_tags)
+
+            if batch_output_action_on_conflict == 'copy':
+                output = [plain_tags]
+            elif batch_output_action_on_conflict == 'prepend':
+                output.insert(0, plain_tags)
+            else:
+                output.append(plain_tags)
+
+            if batch_remove_duplicated_tag:
+                output_path.write_text(
+                    ', '.join(
+                        OrderedDict.fromkeys(
+                            map(str.strip, ','.join(output).split(','))
+                        )
+                    ),
+                    encoding='utf-8'
+                )
+            else:
+                output_path.write_text(
+                    ', '.join(output),
+                    encoding='utf-8'
+                )
+
+            if batch_output_save_json:
+                output_path.with_suffix('.json').write_text(
+                    json.dumps([ratings, tags])
+                )
+
+        print('all done / 识别完成')
+
+    if unload_model_after_running:
+        interrogator.unload()
+
+    return "Succeed"

mikazuki/utils.py

@@ -0,0 +1,46 @@
+import os
+import sys
+import subprocess
+import importlib.util
+
+python_bin = sys.executable
+
+
+def is_installed(package):
+    try:
+        spec = importlib.util.find_spec(package)
+    except ModuleNotFoundError:
+        return False
+
+    return spec is not None
+
+
+def run(command, desc=None, errdesc=None, custom_env=None, live=False):
+    if desc is not None:
+        print(desc)
+
+    if live:
+        result = subprocess.run(command, shell=True, env=os.environ if custom_env is None else custom_env)
+        if result.returncode != 0:
+            raise RuntimeError(f"""{errdesc or 'Error running command'}.
+Command: {command}
+Error code: {result.returncode}""")
+
+        return ""
+
+    result = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True, env=os.environ if custom_env is None else custom_env)
+
+    if result.returncode != 0:
+        message = f"""{errdesc or 'Error running command'}.
+Command: {command}
+Error code: {result.returncode}
+stdout: {result.stdout.decode(encoding="utf8", errors="ignore") if len(result.stdout) > 0 else '<empty>'}
+stderr: {result.stderr.decode(encoding="utf8", errors="ignore") if len(result.stderr) > 0 else '<empty>'}
+"""
+        raise RuntimeError(message)
+
+    return result.stdout.decode(encoding="utf8", errors="ignore")
+
+
+def run_pip(command, desc=None, live=False):
+    return run(f'"{python_bin}" -m pip {command}', desc=f"Installing {desc}", errdesc=f"Couldn't install {desc}", live=live)