nai-aclab 1.1.1 → 1.2.0

package/README.md

@@ -4,6 +4,8 @@ NovelAI에서 여러 작가 태그 조합을 시험해보고, 마음에 드는
 
 예를 들어 같은 캐릭터 프롬프트를 두고 작가 태그의 가중치만 바꿔 여러 장을 만든 뒤, 마음에 드는 이미지의 가중치를 다시 불러와 고정해서 더 테스트할 수 있습니다.
 
+이미지에 `화풍 만족도`와 `신체 안정성` 평점을 남기면 앱이 메인 화풍 작가와 안정화 작가의 적절한 가중치를 따로 학습합니다. 자주 함께 쓰는 베이스와 캐릭터 프리셋은 하나의 세트로 묶어 한 번에 선택할 수 있습니다.
+
 ## 이런 분에게 좋습니다
 
 - NovelAI에서 그림체 조합을 여러 번 실험하는 분
@@ -61,10 +63,10 @@ nai-aclab
 
 1. `API 설정` 메뉴로 이동합니다.
 2. NovelAI API 토큰을 입력합니다.
-3. `목업 모드 사용`을 끕니다.
+3. `API 없이 체험하기`를 끕니다.
 4. `설정 저장`을 누릅니다.
 
-API 토큰을 아직 넣고 싶지 않다면 `목업 모드 사용`을 켜둔 채로 UI만 먼저 테스트할 수 있습니다. 목업 모드에서는 실제 NovelAI API를 쓰지 않고 테스트용 이미지를 만듭니다.
+API 토큰을 아직 넣고 싶지 않다면 `API 없이 체험하기`를 켜둔 채로 UI만 먼저 테스트할 수 있습니다. 체험 모드에서는 실제 NovelAI API를 쓰지 않고 테스트용 이미지를 만듭니다.
 
 대부분의 사용자는 `Endpoint`, `Model`, `Sampler`, `Noise Schedule` 같은 값은 기본값 그대로 두면 됩니다. 처음 설치하면 이미지 모델은 `NAI Diffusion V5 Full`로 설정됩니다.
 
@@ -91,10 +93,41 @@ artist:sample_a
 
 앱은 여기서 `artist:*` 부분만 자동으로 찾아냅니다.
 
-`선택 태그 수`를 비워두면 그 카테고리에 적은 작가 태그를 모두 사용합니다. 일부만 랜덤으로 뽑고 싶을 때만 숫자를 입력하면 됩니다.
+`한 번에 사용할 태그 수`를 비워두면 그 카테고리에 적은 작가 태그를 모두 사용합니다. 일부만 랜덤으로 뽑고 싶을 때만 숫자를 입력하면 됩니다.
+
+아래의 `인식된 artist 태그`에 원하는 태그가 제대로 표시되는지만 확인하면 됩니다. 저장은 입력과 동시에 자동으로 처리됩니다.
 
 ![작가 태그 메뉴](docs/screenshots/02-artists.png)
 
+### 평점으로 취향 학습시키기
+
+이미지를 여러 장 만든 뒤 생성 화면의 실시간 미리보기에서 두 가지 1~5점 평점을 남길 수 있습니다. 히스토리와 가중치 비교에서 이미지를 클릭해 평가해도 됩니다.
+
+| 평점 항목 | 평가 기준 | 다음 생성에서의 변화 |
+| --- | --- | --- |
+| 화풍 만족도 | 완성된 그림체가 내 취향에 맞는지 | 메인 화풍 작가의 포함 확률과 가중치 방향을 조정합니다. |
+| 신체 안정성 | 인체·손발이 자연스럽고 안정화 작가가 메인 화풍을 과하게 덮지 않는지 | 안정화 작가마다 좋은 결과를 낸 가중치를 더 자주 선택합니다. |
+
+4~5점은 좋은 결과, 3점은 중립, 1~2점은 좋지 않은 결과로 해석합니다. 평가가 한두 장뿐일 때는 우연한 결과에 지나치게 끌려가지 않도록 점수를 3점에 가깝게 완화합니다.
+
+알아둘 점:
+
+- `메인 화풍` 역할의 카테고리에는 화풍 만족도만 반영됩니다.
+- `신체 안정화` 역할의 카테고리에는 신체 안정성만 반영됩니다.
+- 안정화 학습은 작가 이름만 보지 않고 `작가 + 실제 가중치` 조합별로 점수를 모읍니다.
+- 아직 평가가 적은 가중치도 가끔 다시 사용하여 더 좋은 값을 놓치지 않도록 합니다.
+- `한 번에 사용할 태그 수`를 비워두면 모든 작가를 사용하므로 포함 확률보다 가중치 선택에 학습 결과가 더 많이 반영됩니다.
+- 타율 테스트는 이미 불러온 작가 조합을 고정해 여러 씬에서 검증하는 기능이므로 평점을 받지 않으며 학습에도 포함되지 않습니다.
+- 학습 내용을 지우고 처음부터 다시 시작하려면 `취향 학습` 메뉴에서 `평점 초기화`를 누르세요.
+
+`취향 학습` 메뉴에서는 메인 화풍 선호 순위와 안정화 작가별 추천 가중치를 따로 확인할 수 있습니다. 작가별 `포함 ×1.20`은 중립 작가보다 선택 가중치가 약 20% 높다는 뜻입니다. 안정화 작가에는 지금까지 시험한 가중치 수, 추천 가중치와 보정 점수가 표시됩니다.
+
+기존 버전에서 남긴 단일 평점은 업데이트 후 `화풍 만족도`로 자동 이전됩니다. 신체 안정성은 업데이트 이후 생성한 결과부터 별도로 평가하면 됩니다.
+
+NAI V5에서는 작가 태그 순서도 결과에 영향을 줄 수 있어, 랜덤 모드에서는 높은 가중치의 태그를 프롬프트 앞과 뒤에 번갈아 배치합니다. 가장 높은 태그가 앞에 올지 뒤에 올지는 생성할 때마다 무작위로 정합니다. 이미지에서 `가중치 불러오기`를 누르면 가중치뿐 아니라 그 이미지의 작가 태그 순서도 함께 고정됩니다.
+
+![취향 학습 메뉴](docs/screenshots/08-learning.png)
+
 ### 2. 프리셋 만들기
 
 `프리셋` 메뉴에서 자주 쓸 프롬프트를 저장합니다.
@@ -114,13 +147,15 @@ artist:sample_a
 
 NovelAI V4+의 멀티 캐릭터 프롬프트는 캐릭터를 쉼표로 합치지 않고 `|`로 나눕니다.
 
+자주 함께 쓰는 `베이스 + 퀄리티`와 `캐릭터` 프리셋은 아래의 `프리셋 세트`에서 하나로 묶을 수 있습니다. 두 프리셋의 이름이 같으면 별도 설정 없이 자동 세트가 만들어집니다. 이후 생성이나 타율 테스트에서 세트 하나만 고르면 두 프리셋이 함께 선택됩니다.
+
 ![프리셋 메뉴](docs/screenshots/03-presets.png)
 
 ### 3. 이미지 생성
 
 `생성` 메뉴에서 사용할 프리셋과 이미지 크기를 고른 뒤 `이미지 생성`을 누릅니다.
 
-생성 중에는 `실시간 이미지 미리보기`에서 결과를 바로 확인할 수 있습니다.
+생성 중에는 `실시간 이미지 미리보기`에서 결과를 바로 확인할 수 있습니다. 생성이 끝난 이미지 카드에는 화풍과 신체 별점이 각각 나타나므로 메뉴를 이동하지 않고 바로 평가할 수 있습니다.
 
 마음에 드는 이미지가 나오면 히스토리나 가중치 비교 화면에서 `가중치 불러오기`를 누릅니다. 그러면 해당 이미지에 쓰인 작가 가중치가 생성 메뉴에 고정됩니다.
 
@@ -147,10 +182,22 @@ NovelAI V4+의 멀티 캐릭터 프롬프트는 캐릭터를 쉼표로 합치지
 
 기본 카테고리는 두 개입니다.
 
-- 메인 그림체 작가
-- 그림체 안정화 작가
+- 메인 그림체 작가: `메인 화풍` 학습 역할
+- 그림체 안정화 작가: `신체 안정화` 학습 역할
+
+필요하면 직접 카테고리를 추가할 수 있습니다. 새 카테고리를 만들 때 `학습 역할`에서 어떤 평점을 사용할지 선택하세요.
 
-필요하면 직접 카테고리를 추가할 수 있습니다.
+이 화면은 태그 입력, 인식 결과, 사용할 태그 수와 가중치 범위를 설정하는 데 사용합니다. 평점 결과와 학습 상태는 별도의 `취향 학습` 메뉴에서 확인합니다.
+
+### 취향 학습
+
+이미지 생성 결과에 남긴 평점이 다음 랜덤 생성에 어떻게 반영되는지 확인하는 화면입니다.
+
+- 화풍 만족도와 신체 안정성의 평가 이미지 수
+- 메인 화풍 작가 선호 순위와 포함 배율
+- 안정화 작가별 추천 가중치와 시험한 가중치 수
+- 카테고리별 학습 역할과 선택 확률 보정 여부
+- 모든 평점과 학습 결과 초기화
 
 ### 프리셋
 
@@ -167,6 +214,7 @@ NovelAI V4+의 멀티 캐릭터 프롬프트는 캐릭터를 쉼표로 합치지
 - 마우스 휠로 확대/축소
 - 드래그로 확대된 이미지 이동
 - 마음에 드는 이미지의 가중치 불러오기
+- 이미지에 화풍 만족도와 신체 안정성 평점 남기기
 - 히스토리 선택 삭제 또는 전체 삭제
 - 이상형 월드컵 실행
 
@@ -193,7 +241,7 @@ NovelAI V4+의 멀티 캐릭터 프롬프트는 캐릭터를 쉼표로 합치지
 여기서 `씬`은 아래 조합을 뜻합니다.
 
 ```text
-씬 = 베이스+퀄리티 프리셋 + 캐릭터 프리셋 + 생성 개수
+씬 = 베이스+퀄리티 프리셋 + 캐릭터 프리셋 + 이미지 해상도 + 생성 개수
 ```
 
 사용 순서:
@@ -206,6 +254,8 @@ NovelAI V4+의 멀티 캐릭터 프롬프트는 캐릭터를 쉼표로 합치지
 
 생성 중 멈추고 싶으면 `생성 중지`를 누르면 됩니다. 현재 처리 중인 이미지가 끝난 뒤 남은 생성을 멈춥니다.
 
+타율 테스트 화면에서는 실시간 미리보기와 전체 진행 상태가 가장 먼저 표시됩니다. 작가 가중치와 순서는 모든 씬에서 그대로 유지되며, 타율 테스트 결과는 취향 학습 평점에서 제외됩니다.
+
 ![타율 테스트 메뉴](docs/screenshots/04-batting-test.png)
 
 ## 이미지 크기
@@ -255,7 +305,7 @@ Windows에서 Python을 설치할 때는 `Add Python to PATH` 옵션을 켜는
 
 ### 이미지가 실제로 생성되지 않고 테스트 이미지만 나옵니다
 
-`API 설정`에서 `목업 모드 사용`이 켜져 있는지 확인하세요. 실제 NovelAI 생성을 하려면 목업 모드를 꺼야 합니다.
+`API 설정`에서 `API 없이 체험하기`가 켜져 있는지 확인하세요. 실제 NovelAI 생성을 하려면 체험 모드를 꺼야 합니다.
 
 ### 기본 endpoint가 아닌 주소라는 경고가 나옵니다
 

package/app.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import base64
 import io
 import json
+import math
 import os
 import random
 import re
@@ -159,6 +160,9 @@ def sanitize_history_item(item: dict) -> dict:
         for key, value in dict(item or {}).items()
         if key not in {"prompt", "negative_prompt", "uc_prompt", "request_path", "request_url"}
     }
+    if "style_rating" not in clean and "rating" in clean:
+        clean["style_rating"] = clean.get("rating")
+    clean.pop("rating", None)
     if "path" in clean:
         clean["path"] = output_ref(clean.get("path", ""))
     return clean
@@ -264,6 +268,11 @@ class Category:
     max_weight: float
     granule: float
     picks: int = 0
+    learning_role: str = ""
+
+    def __post_init__(self) -> None:
+        if self.learning_role not in {"style", "stability"}:
+            self.learning_role = "stability" if "안정" in self.name else "style"
 
 
 @dataclass
@@ -282,6 +291,14 @@ class CharacterPreset:
     quality_override_prompt: str = ""
 
 
+@dataclass
+class PresetSet:
+    name: str
+    base_preset: str = ""
+    character_preset: str = ""
+    auto: bool = False
+
+
 @dataclass
 class ApiSettings:
     token: str = ""
@@ -303,6 +320,7 @@ class ApiSettings:
 
 @dataclass
 class GenerationSettings:
+    preset_set: str = ""
     base_preset: str = ""
     character_preset: str = ""
     count: int = 4
@@ -315,6 +333,7 @@ class GenerationSettings:
 @dataclass
 class BattingScene:
     name: str = ""
+    preset_set: str = ""
     base_preset: str = ""
     character_preset: str = ""
     image_size: str = "portrait"
@@ -326,6 +345,7 @@ class AppState:
     categories: list[Category] = field(default_factory=list)
     base_presets: list[PromptPreset] = field(default_factory=list)
     character_presets: list[CharacterPreset] = field(default_factory=list)
+    preset_sets: list[PresetSet] = field(default_factory=list)
     quality_override_prompt: str = ""
     negative_prompt: str = "lowres, bad anatomy, bad hands, text, error, missing fingers"
     api: ApiSettings = field(default_factory=ApiSettings)
@@ -334,11 +354,321 @@ class AppState:
     history: list[dict] = field(default_factory=list)
 
 
+def sync_auto_preset_sets(state: AppState) -> AppState:
+    base_names = {item.name for item in state.base_presets if item.name.strip()}
+    character_names = {item.name for item in state.character_presets if item.name.strip()}
+    manual_sets = [
+        item
+        for item in state.preset_sets
+        if not item.auto and item.base_preset in base_names and item.character_preset in character_names
+    ]
+    used_names = {item.name for item in manual_sets}
+    auto_sets: list[PresetSet] = []
+    for common_name in sorted(base_names & character_names):
+        matching_manual = next(
+            (
+                item
+                for item in manual_sets
+                if item.base_preset == common_name and item.character_preset == common_name
+            ),
+            None,
+        )
+        if matching_manual:
+            continue
+        set_name = common_name
+        if set_name in used_names:
+            base_name = f"{common_name} (자동)"
+            set_name = base_name
+            suffix = 2
+            while set_name in used_names:
+                set_name = f"{base_name} {suffix}"
+                suffix += 1
+        used_names.add(set_name)
+        auto_sets.append(PresetSet(set_name, common_name, common_name, True))
+    state.preset_sets = manual_sets + auto_sets
+
+    valid_set_names = {item.name for item in state.preset_sets}
+    if state.generation.preset_set not in valid_set_names:
+        matching_set = next(
+            (
+                item
+                for item in state.preset_sets
+                if item.base_preset == state.generation.base_preset
+                and item.character_preset == state.generation.character_preset
+            ),
+            None,
+        )
+        state.generation.preset_set = matching_set.name if matching_set else ""
+    if state.generation.preset_set:
+        selected_set = next(item for item in state.preset_sets if item.name == state.generation.preset_set)
+        state.generation.base_preset = selected_set.base_preset
+        state.generation.character_preset = selected_set.character_preset
+    for scene in state.batting_scenes:
+        if scene.preset_set not in valid_set_names:
+            matching_set = next(
+                (
+                    item
+                    for item in state.preset_sets
+                    if item.base_preset == scene.base_preset
+                    and item.character_preset == scene.character_preset
+                ),
+                None,
+            )
+            scene.preset_set = matching_set.name if matching_set else ""
+        if scene.preset_set:
+            selected_set = next(item for item in state.preset_sets if item.name == scene.preset_set)
+            scene.base_preset = selected_set.base_preset
+            scene.character_preset = selected_set.character_preset
+    return state
+
+
+ARTIST_RATING_PRIOR_COUNT = 4
+ARTIST_RATING_PRIOR_VALUE = 3.0
+
+
+def _artist_learning_role(artist: dict) -> str:
+    role = str(artist.get("learning_role", "")).strip().lower()
+    if role in {"style", "stability"}:
+        return role
+    return "stability" if "안정" in str(artist.get("category", "")) else "style"
+
+
+def _rating_value(item: dict, field: str) -> int:
+    value = item.get(field)
+    if value in (None, "") and field == "style_rating":
+        value = item.get("rating")
+    try:
+        rating = int(value or 0)
+    except (TypeError, ValueError):
+        return 0
+    return rating if 1 <= rating <= 5 else 0
+
+
+def _finish_rating_entry(entry: dict) -> dict:
+    count = entry["count"]
+    smoothed = (
+        entry["rating_sum"] + ARTIST_RATING_PRIOR_VALUE * ARTIST_RATING_PRIOR_COUNT
+    ) / (count + ARTIST_RATING_PRIOR_COUNT)
+    signal = max(-1.0, min(1.0, (smoothed - ARTIST_RATING_PRIOR_VALUE) / 2.0))
+    entry["average_rating"] = round(entry["rating_sum"] / count, 3)
+    entry["smoothed_rating"] = round(smoothed, 3)
+    entry["preference_signal"] = signal
+    entry["selection_multiplier"] = round(math.exp(signal), 3)
+    return entry
+
+
+def artist_rating_summary(history: list[dict]) -> dict[str, dict]:
+    summary: dict[str, dict] = {}
+    for history_entry in history or []:
+        if history_entry.get("type") == "batting_test":
+            continue
+        for item in history_entry.get("items", []) or []:
+            rating = _rating_value(item, "style_rating")
+            if not rating:
+                continue
+            seen = set()
+            for artist in item.get("artists", []) or []:
+                if _artist_learning_role(artist) != "style":
+                    continue
+                tag = str(artist.get("tag", "")).strip()
+                key = tag.casefold()
+                if not key or key in seen:
+                    continue
+                seen.add(key)
+                entry = summary.setdefault(key, {"tag": tag, "count": 0, "rating_sum": 0.0})
+                entry["count"] += 1
+                entry["rating_sum"] += rating
+
+    for entry in summary.values():
+        _finish_rating_entry(entry)
+    return summary
+
+
+def stability_rating_summary(history: list[dict]) -> dict[str, dict]:
+    summary: dict[str, dict] = {}
+    for history_entry in history or []:
+        if history_entry.get("type") == "batting_test":
+            continue
+        for item in history_entry.get("items", []) or []:
+            rating = _rating_value(item, "stability_rating")
+            if not rating:
+                continue
+            seen = set()
+            for artist in item.get("artists", []) or []:
+                if _artist_learning_role(artist) != "stability":
+                    continue
+                tag = str(artist.get("tag", "")).strip()
+                try:
+                    weight = round(float(artist.get("weight", 1.0)), 6)
+                except (TypeError, ValueError):
+                    continue
+                key = tag.casefold()
+                pair_key = (key, weight)
+                if not key or pair_key in seen:
+                    continue
+                seen.add(pair_key)
+                entry = summary.setdefault(
+                    key,
+                    {"tag": tag, "count": 0, "rating_sum": 0.0, "weights": {}},
+                )
+                entry["count"] += 1
+                entry["rating_sum"] += rating
+                weight_entry = entry["weights"].setdefault(
+                    weight,
+                    {"weight": weight, "count": 0, "rating_sum": 0.0},
+                )
+                weight_entry["count"] += 1
+                weight_entry["rating_sum"] += rating
+
+    for entry in summary.values():
+        _finish_rating_entry(entry)
+        weight_rows = []
+        for weight_entry in entry["weights"].values():
+            _finish_rating_entry(weight_entry)
+            weight_rows.append(weight_entry)
+        weight_rows.sort(key=lambda row: row["weight"])
+        best = max(
+            weight_rows,
+            key=lambda row: (row["smoothed_rating"], row["count"], -abs(row["weight"])),
+        )
+        entry["weights"] = weight_rows
+        entry["best_weight"] = best["weight"]
+        entry["best_smoothed_rating"] = best["smoothed_rating"]
+        entry["tested_weight_count"] = len(weight_rows)
+        best_signal = max(-1.0, min(1.0, (best["smoothed_rating"] - ARTIST_RATING_PRIOR_VALUE) / 2.0))
+        entry["selection_multiplier"] = round(math.exp(best_signal), 3)
+    return summary
+
+
+def _weighted_sample_without_replacement(items: list[str], count: int, weights: list[float]) -> list[str]:
+    pool = list(items)
+    pool_weights = [max(0.001, float(value)) for value in weights]
+    result: list[str] = []
+    for _ in range(min(count, len(pool))):
+        selected_index = random.choices(range(len(pool)), weights=pool_weights, k=1)[0]
+        result.append(pool.pop(selected_index))
+        pool_weights.pop(selected_index)
+    return result
+
+
+def _adaptive_weight(values: list[float], preference_signal: float) -> float:
+    if not values:
+        return 1.0
+    if len(values) == 1 or abs(preference_signal) < 0.001:
+        return random.choice(values)
+    likelihoods = []
+    for index in range(len(values)):
+        position = index / (len(values) - 1)
+        likelihoods.append(math.exp(1.35 * preference_signal * (position * 2.0 - 1.0)))
+    return random.choices(values, weights=likelihoods, k=1)[0]
+
+
+def _stability_weight(values: list[float], rating: dict) -> float:
+    if not values:
+        return 1.0
+    if not rating:
+        return random.choice(values)
+    observed = {round(float(row["weight"]), 6): row for row in rating.get("weights", [])}
+    likelihoods = []
+    for value in values:
+        row = observed.get(round(float(value), 6), {})
+        count = int(row.get("count", 0))
+        estimate = float(row.get("smoothed_rating", ARTIST_RATING_PRIOR_VALUE))
+        exploration_bonus = 0.55 / math.sqrt(count + 1)
+        likelihoods.append(math.exp(1.45 * (estimate + exploration_bonus - ARTIST_RATING_PRIOR_VALUE)))
+    return random.choices(values, weights=likelihoods, k=1)[0]
+
+
+def random_artist_tags_for_state(state: AppState) -> list[dict]:
+    result = []
+    style_ratings = artist_rating_summary(state.history)
+    stability_ratings = stability_rating_summary(state.history)
+    for category in state.categories:
+        tags = parse_artist_tags(category.tags)
+        if not tags:
+            continue
+        role = category.learning_role if category.learning_role in {"style", "stability"} else "style"
+        ratings = style_ratings if role == "style" else stability_ratings
+        values = float_range(category.min_weight, category.max_weight, category.granule)
+        pick_count = len(tags) if category.picks <= 0 else min(category.picks, len(tags))
+        selection_weights = [ratings.get(tag.casefold(), {}).get("selection_multiplier", 1.0) for tag in tags]
+        selected_tags = _weighted_sample_without_replacement(tags, pick_count, selection_weights)
+        for tag in selected_tags:
+            rating = ratings.get(tag.casefold(), {})
+            weight = (
+                _adaptive_weight(values, float(rating.get("preference_signal", 0.0)))
+                if role == "style"
+                else _stability_weight(values, rating)
+            )
+            result.append(
+                {
+                    "category": category.name,
+                    "learning_role": role,
+                    "tag": tag,
+                    "weight": weight,
+                    "prompt": weight_tag(tag, weight),
+                    "rating_count": int(rating.get("count", 0)),
+                    "learned_rating": rating.get("smoothed_rating"),
+                }
+            )
+    return result
+
+
+def fixed_artist_tags_for_state(state: AppState) -> list[dict]:
+    result = []
+    for item in state.generation.fixed_artists or []:
+        tag = str(item.get("tag", "")).strip()
+        if not tag:
+            continue
+        try:
+            weight = float(item.get("weight", 1.0))
+        except (TypeError, ValueError):
+            weight = 1.0
+        result.append(
+            {
+                "category": item.get("category", "fixed"),
+                "learning_role": item.get("learning_role") or _artist_learning_role(item),
+                "tag": tag,
+                "weight": weight,
+                "prompt": item.get("prompt") or weight_tag(tag, weight),
+            }
+        )
+    return result
+
+
+def order_artist_tags(artists: list[dict]) -> list[dict]:
+    if len(artists) < 2:
+        return list(artists)
+    shuffled = list(artists)
+    random.shuffle(shuffled)
+    ranked = sorted(shuffled, key=lambda item: float(item.get("weight", 0.0)), reverse=True)
+    ordered: list[dict | None] = [None] * len(ranked)
+    left = 0
+    right = len(ranked) - 1
+    highest_at_front = bool(random.getrandbits(1))
+    for index, artist in enumerate(ranked):
+        place_front = highest_at_front if index % 2 == 0 else not highest_at_front
+        if place_front:
+            ordered[left] = artist
+            left += 1
+        else:
+            ordered[right] = artist
+            right -= 1
+    return [item for item in ordered if item is not None]
+
+
+def artist_tags_for_prompt(state: AppState) -> list[dict]:
+    fixed = fixed_artist_tags_for_state(state)
+    if fixed:
+        return fixed
+    return order_artist_tags(random_artist_tags_for_state(state))
+
+
 def default_state() -> AppState:
-    return AppState(
+    return sync_auto_preset_sets(AppState(
         categories=[
-            Category("메인 그림체 작가", [], 1.0, 1.4, 0.05, 0),
-            Category("그림체 안정화 작가", [], 0.4, 0.9, 0.1, 0),
+            Category("메인 그림체 작가", [], 1.0, 1.4, 0.05, 0, "style"),
+            Category("그림체 안정화 작가", [], 0.4, 0.9, 0.1, 0, "stability"),
         ],
         base_presets=[
             PromptPreset("기본", "", "masterpiece, best quality, very aesthetic, detailed illustration"),
@@ -346,7 +676,7 @@ def default_state() -> AppState:
         character_presets=[
             CharacterPreset("1인 기본", ["1girl, looking at viewer, detailed eyes", "", ""], ["", "", ""]),
         ],
-    )
+    ))
 
 
 def load_state() -> AppState:
@@ -386,10 +716,11 @@ def load_state() -> AppState:
             encoding="utf-8",
         )
     api_data["token"] = load_api_token()
-    return AppState(
+    state = AppState(
         categories=[Category(**item) for item in data.get("categories", [])],
         base_presets=[PromptPreset(**item) for item in base_data],
         character_presets=[CharacterPreset(**item) for item in data.get("character_presets", [])],
+        preset_sets=[PresetSet(**item) for item in data.get("preset_sets", [])],
         quality_override_prompt=quality_override,
         negative_prompt=data.get("negative_prompt", ""),
         api=ApiSettings(**api_data),
@@ -397,10 +728,12 @@ def load_state() -> AppState:
         batting_scenes=[BattingScene(**item) for item in data.get("batting_scenes", [])],
         history=[sanitize_history_entry(item) for item in data.get("history", [])],
     )
+    return sync_auto_preset_sets(state)
 
 
 def save_state(state: AppState) -> None:
     ensure_dirs()
+    sync_auto_preset_sets(state)
     STATE_PATH.write_text(
         json.dumps(state_dict_without_secrets(state), ensure_ascii=False, indent=2),
         encoding="utf-8",
@@ -1180,22 +1513,12 @@ class App(tk.Tk if tk else object):
         save_state(self.state_data)
 
     def random_artist_tags(self) -> list[dict]:
-        result = []
-        for cat in self.state_data.categories:
-            tags = parse_artist_tags(cat.tags)
-            if not tags:
-                continue
-            weights = float_range(cat.min_weight, cat.max_weight, cat.granule)
-            pick_count = len(tags) if cat.picks <= 0 else min(cat.picks, len(tags))
-            for tag in random.sample(tags, pick_count):
-                weight = random.choice(weights) if weights else cat.min_weight
-                result.append({"category": cat.name, "tag": tag, "weight": weight, "prompt": weight_tag(tag, weight)})
-        return result
+        return random_artist_tags_for_state(self.state_data)
 
     def build_prompt(self) -> tuple[str, str, list[dict]]:
         base = self.find_base()
         char = self.find_char()
-        artists = self.random_artist_tags()
+        artists = order_artist_tags(self.random_artist_tags())
         base_chunks = []
         if base and base.prompt.strip():
             base_chunks.append(base.prompt.strip())

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nai-aclab",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "Local web UI for experimenting with NovelAI artist tag weight combinations.",
   "license": "MIT",
   "type": "commonjs",