Replace 2511 sheet with verified Qwen Image 2.1 turbo, mannequin guides and PNG-only export

.gitattributes

@@ -33,3 +33,11 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+assets/cowboy_back.png filter=lfs diff=lfs merge=lfs -text
+assets/cowboy_front.png filter=lfs diff=lfs merge=lfs -text
+assets/full_back.png filter=lfs diff=lfs merge=lfs -text
+assets/full_front.png filter=lfs diff=lfs merge=lfs -text
+assets/knees_back.png filter=lfs diff=lfs merge=lfs -text
+assets/knees_front.png filter=lfs diff=lfs merge=lfs -text
+assets/pose_preview.png filter=lfs diff=lfs merge=lfs -text
+assets/prone_back.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -1,16 +1,4 @@
 __pycache__/
-*.pyc
+*.py[cod]
 .venv/
-out/
-ref_test.png
-verify.py
-exp/
-exp2/
-exp3/
-out2/
-out3/
-experiment*.py
-test_cpu_quant.py
-*.log
-live/
-live_dataset.zip
+.env

LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

NOTICE

@@ -0,0 +1,13 @@
+Character View Sheet - Turbo Trial
+
+The eleven-view selection and feature requirements are based on:
+https://huggingface.co/spaces/darask0/Qwen-Image-Edit-2511-Lora-Sheet
+Upstream Space by darask0 and contributors (Apache-2.0).
+
+This package contains a rewritten experimental application, a procedural
+mannequin renderer, its rendered assets, and CPU-only behavioral tests.
+It does not include model weights or generated character training data.
+
+The application code and procedural mannequin assets are distributed under
+Apache-2.0. Model weights remain subject to their respective upstream licenses.
+Qwen-Image-2.1-Turbo uses the Qwen Research License, not Apache-2.0.

README.md

@@ -1,346 +1,198 @@
 ---
-title: Character View Sheet (Qwen-Image-Edit-2511)
+title: Character View Sheet (Qwen Image 2.1 turbo)
 emoji: 🎨
-colorFrom: pink
-colorTo: indigo
+colorFrom: blue
+colorTo: gray
 sdk: gradio
 sdk_version: 5.49.1
+python_version: "3.12"
 app_file: app.py
 pinned: false
 license: apache-2.0
-short_description: 1 枚の参照画像から LoRA 学習用 11 視点をキャプション付きで生成
+short_description: ポーズ人形による11視点生成の速度・同一性・追従精度を評価する研究デモ
 ---
 
-# キャラクター視点シート生成 Space
-
-参照キャラクター画像を **1 枚** アップロードするだけで、キャラクター LoRA の学習に使う
-**11 視点**を生成し、**kohya-ss 形式のキャプション付きデータセット**として ZIP で出力する。
-
-生成する視点は**チェックボックスで個別に外せる**。ZeroGPU の無料枠は要求秒数で
-入場判定されるため、不要な視点を外すほど通りやすくなる。
-
-## 視点カタログ
-
-| # | 視点 | ポーズ基準 | カメラ (`<sks>`) | 条件画像 | 解像度 |
-|---|---|---|---|---|---|
-| 1 | 全身 正面 | 立ち | `front view eye-level shot wide shot` | 参照画像 | 832×1216 |
-| 2 | 全身 左側面 | 立ち | `left side view eye-level shot wide shot` | 全身正面 | 832×1216 |
-| 3 | 全身 右側面 | 立ち | `right side view eye-level shot wide shot` | 全身正面 | 832×1216 |
-| 4 | 全身 背面 | 立ち | `back view eye-level shot wide shot` | 全身正面 | 832×1216 |
-| 5 | カウボーイショット 正面 | 立ち | `front view eye-level shot medium shot` | **全身正面のクロップ** | 1024×1024 |
-| 6 | カウボーイショット 背面 | 立ち | `back view eye-level shot medium shot` | **全身背面のクロップ** | 1024×1024 |
-| 7 | 上半身 正面 | 立ち | `front view eye-level shot close-up` | **全身正面のクロップ** | 1024×1024 |
-| 8 | 顔 正面 | 立ち | `front view eye-level shot close-up` | **全身正面のクロップ** | 1024×1024 |
-| 9 | 膝抱え 正面 | 膝抱え座り | `front view eye-level shot wide shot` | 全身正面 | 832×1216 |
-| 10 | 膝抱え 背面 | 膝抱え座り | `back view eye-level shot wide shot` | 膝抱え正面 | 832×1216 |
-| 11 | うつ伏せ 後方から | うつ伏せ | `back view high-angle shot wide shot` | 全身正面 | 1216×832 |
-
-解像度は kohya-ss の標準バケット (いずれも約 1MP) に合わせてあるため、学習前のリサイズが不要。
-
-### 寄り視点はクロップした参照画像で条件付けする (実機検証で確定)
-
-RTX PRO 6000 Blackwell (ZeroGPU と同世代) での実測により、**全身画像を条件にして
-プロンプトで「寄れ」と指示しても、Qwen-Image-Edit は入力のフレーミングを保とうとして
-全身のまま出力する**ことが分かった。言い回しを 8 通り試しても、カウボーイショットは
-一度も成功しなかった。
-
-そのため寄り視点 (#5-#8) では、**条件画像をあらかじめ目的の構図に切り出してから**
-渡している (`framing.py`)。白背景から被写体のバウンディングボックスを求め、
-頭頂から一定割合 (顔 20% / 上半身 45% / カウボーイ 72%) を切り出す方式。
-
-| 視点 | プロンプトのみ | クロップ条件付け |
-|---|---|---|
-| 顔 | ✅ | ✅ |
-| 上半身 | 腰上まで | ✅ 胸上 |
-| **カウボーイ 正面/背面** | ❌ **全身のまま** | ✅ **腿上** |
-
-あわせて、寄り視点では**全身のポーズ説明文を外している**。「両腕を腿の脇に下ろし、
-脚は左右対称に…」という記述が寄り指示と競合して、全身が出力される原因になっていた。
-
-UI の「寄り視点を高品質モード」を有効にすると、クロップ画像に加えて全身画像も
-条件に渡す (2 枚入力)。情報量が増えて精細になるが、条件系列が倍になるため
-生成時間は約 1.8 倍 (実測 4.6 秒 → 8.2 秒) になる。
-
-視点は `views.py` の `VIEWS` テーブルに 1 行として定義されている。UI のチェックボックス・
-duration 見積り・キャプションの構図タグは**すべてこのテーブルから導出**されるので、
-斜め 45 度 (quarter view) や表情差分を足したい場合は行を追加するだけでよい。
-
-## モデル構成
-
-| 役割 | リポジトリ | 備考 |
-|---|---|---|
-| ベース画像編集モデル | [`Qwen/Qwen-Image-Edit-2511`](https://huggingface.co/Qwen/Qwen-Image-Edit-2511) | `QwenImageEditPlusPipeline` |
-| 高速化 LoRA | [`lightx2v/Qwen-Image-Edit-2511-Lightning`](https://huggingface.co/lightx2v/Qwen-Image-Edit-2511-Lightning) | 4-step 蒸留 |
-| **カメラ角度 LoRA** | [`fal/Qwen-Image-Edit-2511-Multiple-Angles-LoRA`](https://huggingface.co/fal/Qwen-Image-Edit-2511-Multiple-Angles-LoRA) | 96 カメラ位置 (8 方位 × 4 仰角 × 3 距離) |
-| タガー A | [`SmilingWolf/wd-swinv2-tagger-v3`](https://huggingface.co/SmilingWolf/wd-swinv2-tagger-v3) | ONNX / CPU 実行 |
-| タガー B | [`Grio43/OppaiOracle`](https://huggingface.co/Grio43/OppaiOracle) | ONNX / CPU 実行 |
-
-### カメラ指定について
-
-以前は `"Move the camera to a back-facing position so the full body..."` のような散文で
-角度を指示していたが、再現性が低かった。現在は角度 LoRA のトリガ語彙を使っている:
-
-```
-<sks> {方位} {仰角} {距離}
-```
-
-- 方位 (8): `front view` / `front-right quarter view` / `right side view` / `back-right quarter view` / `back view` / `back-left quarter view` / `left side view` / `front-left quarter view`
-- 仰角 (4): `low-angle shot` / `eye-level shot` / `elevated shot` / `high-angle shot`
-- 距離 (3): `close-up` / `medium shot` / `wide shot`
-
-この語彙以外の文字列は効かない。「うつ伏せを後ろから見下ろす」構図が
-`back view` + `high-angle shot` として厳密に指定できるのがこの方式の利点。
-
-### 生成の流れ
-
-1. ユーザーの参照画像から **立ちポーズの基準画像 (アンカー)** を作る。
-2. 各視点は、そのポーズのアンカーを条件入力にして**カメラだけを動かして**生成する。
-3. ポーズが違う視点 (膝抱え / うつ伏せ) は、立ちアンカーからそのポーズのアンカーを作り、
-   そこからカメラを動かす。
-4. アンカーのカメラと一致する視点は、アンカー画像をそのまま流用して生成を 1 回省く。
-
-全 11 視点を選んだ場合、生成回数はちょうど 11 回。一部だけ選んだ場合は必要なアンカーだけが
-作られる (例: 「膝抱え 背面」だけを選ぶと 立ち → 膝抱え → 背面 の 3 回)。
-
-## ZeroGPU クォータ設計
-
-**要点: ZeroGPU のクォータは「実行時間」ではなく「要求した `duration`」ぶん消費される。**
-10 秒で終わる処理でも 60 秒要求すれば 60 秒引かれる。入場判定も
-`残りクォータ < 要求 duration` で即拒否される。
-
-| アカウント | 1 日のクォータ |
-|---|---|
-| 未認証 | 120 秒 |
-| 無料会員 | 300 秒 |
-| PRO | 2400 秒 (延長可) |
-
-さらに **`xlarge` は要求 duration の 2 倍が引かれる**。本モデルは 53.8GB あり
-`large` (48GB) に載らないため `xlarge` 必須で、この 2 倍が常にかかる。
-
-既定では**分割せず 1 回の GPU 呼び出しにまとめる** (`CHUNK_SIZE=12`)。
-分割すると GPU 取得の固定費 (約 9 秒) を毎回払い、それも 2 倍されるため、
-総消費がかえって増える。分割の利点 (残クォータが少なくても途中まで進める) より、
-総量を抑えるほうが無料枠では効く。
-
-| 選択 | 生成枚数 | 要求 | **実消費** | 無料 (300秒) | 未認証 (120秒) |
-|---|:---:|:---:|:---:|:---:|:---:|
-| 全 11 視点 | 11 | 67 秒 | **134 秒** | ✅ 1日2回 | ❌ |
-| 全 11 視点 (高品質モード) | 11 | 83 秒 | 166 秒 | ✅ | ❌ |
-| 三面図のみ (4視点) | 4 | 32 秒 | 64 秒 | ✅ | ✅ |
-| 最小構成 (2視点) | 2 | 22 秒 | 44 秒 | ✅ | ✅ |
-
-> 見積り式は `duration = 12 + 5 × 枚数`。係数は環境変数
-> `CALL_OVERHEAD_SEC` / `PER_VIEW_SEC` / `CHUNK_SIZE` で調整できる。
-
-**ZeroGPU 実測 (xlarge / MIG 4g.96gb / bf16)**
-
-| 項目 | 実測 |
-|---|---|
-| GPU 取得 + モデル転送 | 約 9 秒 |
-| 1 枚目 (ウォームアップ込) | 4.8 秒 |
-| 2 枚目以降 | **2.9 秒/枚** (832×1216, 4 step) |
-| 4 枚チャンクの GPU 時間 | 13.5 秒 |
-| 全 11 視点の実行 (DL・タグ付け・ZIP 込み) | 約 255 秒 |
-
-参考: ローカルの RTX PRO 6000 Blackwell (フル 96GB / fp8) では 4.4 秒/枚だった。
-ZeroGPU の `xlarge` は MIG 4g.96gb で、実測ではこちらのほうが速い。
-
-なお一部の視点は、寄りの切り出し元やポーズ基準として**中間生成**を必要とする。
-例えば「カウボーイ背面」だけを選んだ場合は 立ち → 全身背面 → カウボーイ背面 の
-3 回生成になる。UI のクォータ表示はこの中間生成も含めた実消費秒数を出す。
-
-> **未達の目標**: 当初は未認証ユーザー (120 秒) でも全 11 視点を通すことを狙っていたが、
-> `xlarge` 強制により 134 秒となり達成できていない。`large` (2 倍消費なし) に戻すには
-> モデルを 42 GiB 未満に縮める必要がある (fp8 transformer の採用など)。
-
-## 高速化 (fp8 + FlashAttention-3 + AoTI)
-
-ZeroGPU は 2026/05 に **H200 (~70GB) から RTX Pro 6000 Blackwell** へ移行し、
-既定の `large` サイズは **48GB** になった。Qwen-Image-Edit-2511 は bf16 で
-
-- transformer: 40.9 GB
-- text encoder (Qwen2.5-VL-7B): 16.6 GB
-- 合計: **約 57 GB**
-
-あり、余裕がない。そのため `optimization.py` で
-
-1. FlashAttention-3 の attention processor を適用
-2. torchao の fp8 動的量子化 (transformer を約半分に)
-3. PyTorch ahead-of-time コンパイル (`spaces.aoti_compile`)
-
-を行う。速度改善 (1.3-1.8×) 以上に **VRAM を削ること**が目的。
-系列長を動的次元にしてあるので、視点ごとに解像度が変わっても再コンパイルは走らない。
-
-### fp8 量子化を CPU 側でやってはいけない (デプロイして判明)
-
-ローカル GPU では「CPU で量子化してから GPU へ転送」がロード時ピークを
-**55.1GB → 34.8GB** に下げられて有利だった。しかし **ZeroGPU では動かない**。
-
-ZeroGPU はモジュール階層の `.to("cuda")` を CUDA エミュレーション層
-(`spaces/zero/torch/patching.py`) で横取りし、テンソルを `aten.empty_like` で
-スナップショットする。torchao の `Float8Tensor` はこの演算を実装していないため、
-起動時に `NotImplementedError` で落ちる。
-
-```
-NotImplementedError: Float8Tensor dispatch: attempting to run unimplemented
-operator/function: func=<OpOverload(op='aten.empty_like', overload='default')>
+# Character View Sheet (Qwen Image 2.1 turbo)
+
+参照キャラクター画像と、付属する11種類のポーズ人形を使い、各視点を1枚ずつ生成する
+Hugging Face Gradio Space用の研究試作版です。**ローカル実機で11視点生成を検証済み**です。
+公開Space: [Character View Sheet (Qwen Image 2.1 turbo)](https://huggingface.co/spaces/darask0/Qwen-Image-Edit-2511-Lora-Sheet)
+
+**HF ZeroGPU largeでも、認証情報を送らないAPI接続から標準サイズ11視点の完走を確認しました。**
+2026-10-12、GPU内処理68.0秒、割当・転送込み68.5秒、
+ピーク割当33.01GiB。角度LoRAあり・人形あり・白背景全身の切り出しあり・Seed0です。
+確認GPUは`NVIDIA RTX PRO 6000 Blackwell Server Edition MIG 2g.48gb`。110秒予約でPNG11枚を取得しました。
+1例・1回の匿名API試験で、ブラウザ操作や他の入力・混雑時の完走を保証するものではありません。
+上記は別の検証用Spaceで取得した計測です。この検証済みTurbo版で既存の2511 Spaceを置き換えました。
+URLは従来のものを継続し、表示名・使用モデル・アプリ内容を更新しています。
+
+RTX PRO 6000 Blackwell（96GB、PyTorchの割当を48GiBに制限）では、標準サイズ・速度優先設定で
+11枚を推論36.1秒、PNG保存込み39.3秒、ピーク割当33.01GiBで生成しました。
+これは全GPUの演算能力を使用した値です。ZeroGPU largeの半GPU性能、転送、待ち時間は再現していません。
+高速設定は11枚を推論17.7秒・保存込み19.0秒で完走しました。
+人物1例の評価で、構図や衣装の細部に誤りが残るため、学習用画像は選別してください。
+
+同じ人物では、標準・速度優先＋参照切り出し＋2.1角度LoRA（強度0.8）が最も良い結果でした。
+この条件は11枚を推論37.3秒・保存込み40.2秒、ピーク割当33.02GiBで完走しました。
+短パン化と背中への胸模様の転写が解消し、顔・上半身の寄り構図も改善しましたが、
+左右非対称の袖模様、背景色、細かな関節位置は一致しません。
+
+用途は研究・評価です。未ログイン利用者も参加できる研究用デモとして、
+生成速度、キャラクター同一性、ポーズ人形への追従精度を検証する想定です。
+
+対象モデルは `Qwen/Qwen-Image-2.1-Turbo`。未ログイン利用者の120秒枠で11視点を
+生成できるよう、最大110秒のGPU予約、低解像度設定、実行時間の記録を用意しています。
+110秒は処理の上限であり、11枚の完成所要時間を測った値ではありません。
+
+## 変更内容
+
+- 元Spaceと同じ11視点を選択可能。
+- キャプション生成、タガー、比較レポート、トリガーワード／除外タグ設定を削除。
+- 出力ZIPは `dataset/NN_view.png` のみ。TXT、キャプション、ポーズ人形は混入しません。
+- 全視点でユーザーの元画像を参照。生成画像を次の視点に回す中間アンカー生成はありません。
+- 白背景の直立全身画像に限り、寄り4視点の参照切り出しを選べます（既定は無効）。
+- 11枚のグレーのポーズ人形PNGを同梱。人形参照のオン・オフを比較可能。
+- Turboの保存済み8ステップsigmaを使用。CFG=1、KV cache有効。
+- GPUサイズは明示的に `large`。1ジョブずつ処理し、VAE tilingを有効化。
+- 時間が不足しそうなら次の視点を開始せず、完成済みの画像を返します。
+- モデル内のステップ境界でも期限を確認。通常の後続視点エラーでも完成画像を保持します。
+  ただしプロセス強制終了・GPU割当失敗・ステップ途中の長時間停止は救済できません��
+
+## ポーズ人形
+
+![11種類の人形](assets/pose_preview.png)
+
+`pose_guides.py` が同じ立体モデルを異なるカメラから投影して作ります。
+画像生成AIや外部の人形画像は使用していません。個別PNGには文字が入りません。
+一覧だけに確認用ラベルがあります。
+
+1. 全身の正面・左側面・右側面・背面
+2. 腿上の正面・背面
+3. 上半身正面・顔正面
+4. 膝を抱えた座り姿の正面・背面
+5. うつ伏せの後方俯瞰
+
+条件画像は `[元のキャラ画像, その視点の人形画像]` の2枚です。
+「白背景の直立全身画像」の切り出しを有効にすると、腿上・上半身・顔用に元画像から
+それぞれ前景高さの72%・45%・20%を切り出します。縦横比を保ち、白い余白を付けます。
+背景付き画像、座り姿、既に寄った画像には使わないでください。寄り構図は改善しましたが、
+切断面を衣装の裾と解釈し長ズボンを短パンに変える例もあり、実験オプションです。
+指示文でも「Image 1から外見、Image 2からポーズと構図」を区別します。
+これは画像編集の参照機能であり、ControlNetや骨格座標による強制制御ではありません。
+顔や衣装の保持、背面の補完、関節配置への追従は生成結果で確認する必要があります。
+人形は標準体型のため、デフォルメ体型では余白や手足の配置を調整する余地があります。
+
+再生成:
+
+```bash
+python pose_guides.py --regenerate
 ```
 
-量子化するなら GPU コンテキスト内で行うこと
-([zerogpu-aoti](https://huggingface.co/blog/zerogpu-aoti) と同じ手順)。
-現状 fp8 と AoTI は既定で無効 (`ENABLE_AOTI=1` で有効化)。
-
-### `large` に戻すには (未実施)
-
-`xlarge` の 2 倍消費をやめるには、登録テンソル量を 42 GiB 未満にする必要がある。
-候補は fp8 済みの transformer
-[`prithivMLmods/Qwen-Image-Edit-Rapid-AIO-V19`](https://huggingface.co/prithivMLmods/Qwen-Image-Edit-Rapid-AIO-V19)
-(19.0 GiB, diffusers 形式, 非 gated) を `QwenImageEditPlusPipeline.from_pretrained(..., transformer=...)`
-で差し込む方法。ただし
-
-- ネイティブ fp8 重みへの PEFT の `Linear.merge()` 直接適用は安全でない。
-  bf16 で読み込んで fuse したあと `enable_layerwise_casting(storage_dtype=torch.float8_e4m3fn,
-  compute_dtype=torch.bfloat16)` で保存する手順が必要。
-- 「Rapid AIO」は蒸留系の改変が入っている可能性があり、Lightning LoRA を
-  重ねてよいか要確認。
-
-実施する場合は `GPU_SIZE=large` に戻し、`QUOTA_MULTIPLIER` が 1 になることを確認する。
-
-### 実測値 (RTX PRO 6000 Blackwell / fp8 / FA3・AoTI なし)
-
-| 項目 | 実測 |
-|---|---|
-| ロード + fp8 量子化 | 32.4 秒 |
-| ロード後 VRAM | 34.8 GB |
-| **生成時ピーク VRAM** | **38.9 GB** (48GB 枠内) |
-| 1 視点あたり | 4.4 秒 |
-| 11 視点 合計 | 48.0 秒 |
-| キャプション 11 視点 × 2 タガー | 22.6 秒 (CPU) |
-
-ZeroGPU では FA3 と AoTI が有効になるため、これより速くなる見込み。
-
-問題が出た場合は環境変数で個別に切れる: `DISABLE_FP8` / `DISABLE_AOTI` / `DISABLE_FA3`。
-いずれも失敗時は自動でフォールバックし、Space 自体は止まらない。
-
-### ⚠️ `@spaces.GPU` には必ず `size` を明示すること (最重要)
-
-**これが本 Space が一時的にまったく生成できなくなっていた原因。**
-`spaces 0.51.1` の GPU サイズ自動選択にバグがある。
-
-1. 起動時に `zero/__init__.py` の `startup()` が登録テンソル量を測り、
-   Blackwell の閾値 `45097156608` (42.0 GiB, `zero/configs.json`) を超えると
-   `_default_gpu_size = 'xlarge'` を立てる。
-2. ところが `zero/client.py` の `schedule()` は、その既定値を **duration の計算には
-   使うのに、実際の割り当て要求には元の `gpu_size=None` をそのまま渡す**。
-3. 結果、53.8GB のモデルが 48GB の `large` に転送されて worker が即死する。
-4. `worker_init()` は `torch.move()` を**デコレート関数の実行前**に呼ぶため、
-   `wrappers.py` が `res is None` を受けて `"GPU task aborted"` を投げる。
-
-このため **Python トレースバックが一切残らず**、引数を取らない自己診断関数まで
-含めてあらゆる GPU 呼び出しが同じように落ちる。要求 duration を 212 秒まで
-上げても変わらない (duration の問題ではない)。公式 `Qwen/Qwen-Image-Edit-2511`
-Space が動くのは `spaces` 0.50.2 のままリビルドされていないから。
-
-対策は `@spaces.GPU(..., size="xlarge")` の明示指定のみ。`spaces` を
-`requirements.txt` でピンして回避することは**できない** —
-HF Spaces がビルドコマンドで `spaces==0.51.1` を強制注入するため
-`ResolutionImpossible` になる。
-
-診断用に `gpu_selftest` / `gpu_pipe_selftest` を UI の「診断」に残してある。
-GPU が取れているかを最小コストで確認できる。
-
-### 依存について
-
-- **torch は書かない。** ベースイメージのものを使う (現在 2.11.0+cu130)。
-- **`spaces` と `gradio` も書かない。** ビルドコマンドで強制注入される。
-- `kernels` は 0.15 以降 `get_kernel()` に `version=` / `revision=` が必須になり、
-  vendoring した FA3 processor の呼び出しが通らないため `kernels<0.15` に固定。
-  ただし現行 ZeroGPU には対応するカーネルビルドが無く
-  (`min() arg is an empty sequence`)、**FA3 は現状使えない**。フォールバックして
-  既定の attention で動作する。
-
-> 角度 LoRA は AoTI コンパイル後に切り替えられないため、起動時に fuse して固定している
-> (既定強度 0.9、`ANGLES_LORA_SCALE` で変更可)。
-
-## キャプション生成 (WD Tagger v3 vs OppaiOracle)
-
-**タグ付けは onnxruntime の CPU 実行**にしてあり、ZeroGPU のクォータを一切消費しない。
-
-| | WD Tagger v3 | OppaiOracle V1.1 |
+## HF Spaceでの検証手順
+
+1. このディレクトリの内容をGradio Spaceのルートに置きます。
+2. HardwareをZeroGPUに設定します。アプリの閲覧者にHFログインを要求する設定はありません。
+3. 既定の `GPU_SIZE=large`、標準・速度優先、人形参照ありで起動します。公開Spaceは `ENABLE_ANGLES_LORA=1` で、検証済みの2.1角度LoRAを使用します。
+4. 所有者の利用枠で、正面・側面・背面をまず比較し、続いて11視点を生成します。
+5. 「実行時間の記録」からJSONを保存し、全11視点の完成、ピークVRAM、1枚ごとの時間を確認します。
+6. 同じ参照画像・Seed・出力サイズで人形参照のオン／オフを比較します。
+7. 未ログイン状態では、その日の残り利用枠がある状態で11視点を検証します。
+
+HF上で依存インストール・起動・ZeroGPU推論・画像ZIP取得を確認済みです。
+HFのビルドが供給したTorch2.13.0を維持し、Torchvision0.28.0へ解決されました。
+Spaces0.51.3、Gradio5.49.1、Python3.12.12、Transformers5.19.0、PEFT0.21.2、Accelerate1.15.0で動作しました。
+`requirements.txt` はQwen公式案内に沿い、Turboを扱える上流Diffusersコミットを固定しました。
+ZeroGPUが供給するtorch／spaces／Gradioはrequirementsで重ねて固定しません。
+
+旧 `tagging.py` / `optimization.py` / `qwenimage/` / `bench/` は削除しました。
+旧requirementsを追加せず、本版のものを使用します。
+
+## 解像度と時間枠
+
+| 設定 | 縦長 | 正方形 | 横長 | 条件画像の面積設定 |
+|---|---|---|---|---|
+| 高速 | 512×768 | 640×640 | 768×512 | `output_resolution=640` |
+| 標準・速度優先（既定） | 832×1216 | 1024×1024 | 1216×832 | `output_resolution=640` |
+| 標準・細部優先 | 832×1216 | 1024×1024 | 1216×832 | `output_resolution=1024` |
+
+条件画像をPILで縮小するだけではモデル内部で拡大されるため、`output_resolution`も明示しています。
+高速モードの画像は標準より小さく、学習用細部の情報量も減ります。
+標準・速度優先は出力サイズを保ち、参照画像の処理面積を減らします。
+細かい模様の再現は別途比較が必要です。元2511版との同一条件の速度比較は未実施です。
+
+GPU時間枠は `min(MAX_GPU_SECONDS, max(45, 15 + 10 × 視点数))` 秒。
+この式は測定結果からの推定ではなく、試作の予約上限です。
+初期転送に15秒、生成終了処理に6秒の余裕を取り、残り時間で生成します。
+11視点は110秒予約、`large`では120秒の匿名日次枠内に予約できますが、他のSpaceでの利用や
+残り枠、混雑、実行速度によって利用・完成を保証するものではありません。
+
+公式の現行仕様では `large`は48GB・1倍消費、`xlarge`は96GB・2倍消費です。
+`xlarge`へ変更すると11視点の予約が220秒相当になり、未ログイン枠を超えます。
+Turboのsafetensorsファイル合計は約32.44GBで、演算時のVRAMはこれより増えます。
+ローカル実測で標準解像度・2参照画像のピーク割当は36.10GiB、標準・速度優先では33.01GiBでした。
+HF largeでも標準・速度優先のピーク割当は33.01GiBでした。
+
+| Space Variable | 既定値 | 意味 |
 |---|---|---|
-| タグ数 | 10,861 | 19,294 |
-| 入力 | 448×448 NHWC / BGR / 0-255 | 448×448 NCHW / letterbox (114,114,114) / mean=std=0.5 |
-| ONNX 入出力 | `input` → `output` | `pixel_values` + `padding_mask` → `probabilities` |
-| 既定閾値 | 0.35 | **0.805** (`pr_thresholds.json` の micro.f1_optimal) |
-| ライセンス | Apache-2.0 | Apache-2.0 |
-
-**���者はスコア分布がまったく違う。** 実測で OppaiOracle は閾値 0.805 で 21 タグ、
-0.5 で 445 タグ、0.35 で 2768 タグになる。同じ閾値で比較すると意味を成さないため、
-UI のスライダーはタガーごとに別レンジにしてある。
-
-UI で「両方 (比較する)」を選ぶと、ZIP に比較レポート `caption_comparison.md` が入り、
-共通タグ / 片方だけのタグが視点ごとに一覧できる。
-
-### 構図タグは推論に頼らない
-
-`full body` / `upper body` / `portrait` / `cowboy shot` / `from behind` / `from above` /
-`lying` / `on stomach` などの構図タグは、**カメラパラメータから決定的に注入**している。
-タガーは構図を安定して当てられないため。
-
-さらに、確定タグと矛盾するタガー出力は落とす。例えばうつ伏せの視点で、タガーが条件付け元の
-立ち絵に引きずられて `standing` を返すことがあるが、これは除去される (実測で発生する)。
-
-### ZIP の構成
-
+| `GPU_SIZE` | `large` | `large` / `xlarge`。明示指定 |
+| `MAX_GPU_SECONDS` | `110` | 45〜110。実行時間枠の上限 |
+| `ENABLE_ANGLES_LORA` | `0` | `1`で2.1用Multiple-Angles v2を追加する比較実験 |
+
+## 角度LoRA
+
+旧2511用のLightning／Multiple-Anglesは使用しません。
+2.1は異なるモデル構造です。必要なら `akhaliq/Qwen-Image-2.1-Multiple-Angles-LoRA` の
+v2、強度0.8を起動時に適用できます。`<mva>`語彙を使います。
+作者の学習実装とDiffusersではMLPの層名と構造が異なるため、`angles_adapter.py`が
+結合されたgate/upのLoRAを分割変換し、全224モジュール・448テンソルの読込を確認します。
+未対応層を黙って無視しません。変換後のモデルで11視点の実GPU推論を完走しました。
+本検証の人物1例では衣装と寄り構図が改善しました。品質比較用オプションで、既定では無効です。
+この比較を再現するには `ENABLE_ANGLES_LORA=1`、標準・速度優先、白背景全身用の切り出しを選びます。
+
+## 利用条件
+
+アプリのコードと手続き的に作成した人形はApache-2.0です。
+**モデル重みのライセンスは別**で、TurboはQwen Research Licenseです。
+公開本文では非商用を研究・評価目的と定義し、商用利用には別許諾を求めています。
+無料公開であることだけから利用可能とは判断できません。
+出力を用いて学習・改善したAIモデルを配布・提供する場合、関連文書への
+`Built with Qwen` または `Improved using Qwen` 表示条件があります。
+本試作版は、上記の研究・評価用途を前提とします。
+
+## ローカルで検証した範囲
+
+PillowとPython標準ライブラリで、CPU側のデータ処理テストを実行できます。
+モデル重みをダウンロードすることはありません。
+
+```bash
+python -m unittest discover -s tests -v
 ```
-dataset/01_full_front.png
-dataset/01_full_front.txt      <- 主タガーのキャプション (kohya-ss 形式)
-...
-captions_alt/01_full_front.txt <- 比較用のもう一方のタガー
-caption_comparison.md
-```
-
-`dataset/` をそのまま kohya-ss の学習フォルダに指定できる。
 
-### キャプションの形
+画像だけのZIP、11視点の選択、各視点の参照画像、途中失敗時の保存、時間枠の中断、
+入力画像の透過処理・縮小、選択順に依存しないSeedを確認します。
+人形画像は目視および寸法・RGBモードを確認しました。
+CPUテストは生成品質を評価しません。GPUベンチマークは次のコマンドで別途実行できます。
+モデルのダウンロードには約33GB、実行にはCUDA環境が必要です。
 
+```bash
+python benchmark_local.py --image character.png --output-dir results \
+  --resolution balanced --pose-guides on --reference-crop on --memory-limit-gib 48
 ```
-{トリガーワード}, {構図の確定タグ}, {タガーが推定したタグ}
-```
-
-除外タグ欄に髪色・目色などを入れておくと、その特徴をキャプションから外して
-LoRA 側に焼き込める。背景を焼き付けたくない場合に備えて、`white background` /
-`simple background` は確定タグとして**明示的に**入れてある (無名の前提にしない)。
-
-## Krea 2 Turbo との比較
-
-「Krea 2 turbo に置き換えるべきか」を検討した結果、**Qwen-Image-Edit-2511 を継続**する。
-
-| 項目 | Qwen-Image-Edit-2511 | Krea 2 Turbo |
-|---|---|---|
-| タスク | **画像編集がネイティブ** (多画像入力可) | stock diffusers では **text-to-image 専用** |
-| パラメータ | 20B MMDiT + Qwen2.5-VL-7B | 12B MMDiT + Qwen3-VL-4B |
-| 重み (bf16) | 40.9GB + 16.6GB ≈ 57GB | ~24GB + ~8GB ≈ **32GB** |
-| ステップ | 4 (Lightning LoRA), true_cfg 1.0 | 8 (TDM 蒸留), guidance 0.0 |
-| diffusers | `QwenImageEditPlusPipeline` | `Krea2Pipeline` (0.39.0+, t2i のみ) |
-| Hub | 非 gated / **Apache-2.0** | `krea/Krea-2-Turbo` は **gated** / Krea 2 Community License |
-| 編集手段 | ネイティブ | 非公式 LoRA + ComfyUI 専用ノード、または非公式 diffusers 移植 |
-| カメラ角度制御 | **専用 LoRA が存在 (96 カメラ位置)** | 同等物なし |
-| 公開ホスト時の義務 | なし | **入出力セーフティ分類器の実装が必須** |
-
-VRAM が軽いのは Krea 2 の明確な利点。しかし「参照画像 1 枚から同一キャラの多視点を派生させる」
-という本 Space の中核機能が公式に存在せず、角度制御 LoRA のエコシステムも無い。
-
-実測比較は別 Space [`Krea2-vs-Qwen-Edit-Bench`](./bench) で行う (同リポジトリの `bench/` を参照)。
 
-## ライセンス・注意
+`--reference-crop on` は白背景・直立全身の場合だけ指定します。
+`--resolution fast/standard/balanced`、`--angles-lora on/off`、`--repeat 2`で比較できます。
+`--create-sample`は検証用の成人キャラクターを先に生成し、その時間を11枚の計測から分離します。
+`--image`と`--create-sample`を省略すると人形の速度試験となり、人物同一性の評価には使えません。
 
-- 本 Space コード: **Apache-2.0**
-- 使用モデル各種のライセンスは上流リポジトリに従う
-- アップロード画像は**第三者の著作物・肖像権を侵害しないものに限る**
+計測JSONは各視点の同期済み推論時間、PNG保存込み時間、ロード時間、ピークVRAM、
+モデルrevision、プロンプト、Seedを記録します。48GiB制限はPyTorch allocatorだけを制限し、
+半GPUの演算性能やZeroGPU環境を再現しません。
 
-## ベースにした Space
+## 一次資料（2026-10-12確認）
 
-[tori29umai/Qwen-Image-2509-CharacterSheet](https://huggingface.co/spaces/tori29umai/Qwen-Image-2509-CharacterSheet)
-(1 枚から 4 視点ターンアラウンドを生成) を参照。`optimization.py` と
-`qwenimage/qwen_fa3_processor.py` は同 Space の実装を流用している。
+- [置き換え前の11視点Spaceのソース](https://huggingface.co/spaces/darask0/Qwen-Image-Edit-2511-Lora-Sheet/tree/0e9ee21fcd738c71b4ccd0606e854b79521fbbd3)
+- [Turbo公式モデルカード](https://huggingface.co/Qwen/Qwen-Image-2.1-Turbo)
+- [使用するDiffusers実装](https://github.com/huggingface/diffusers/blob/85c9fa4caee33d1c5b473395784471d2d7957c1b/src/diffusers/pipelines/qwenimage21/pipeline_qwenimage21.py)
+- [2.1用角度LoRAの作者資料](https://huggingface.co/akhaliq/Qwen-Image-2.1-Multiple-Angles-LoRA)
+- [HF ZeroGPU仕様・利用枠](https://huggingface.co/docs/hub/en/spaces-zerogpu)
+- [Turboライセンス](https://huggingface.co/Qwen/Qwen-Image-2.1-Turbo/blob/main/LICENSE)

angles_adapter.py

@@ -0,0 +1,128 @@
+"""Lossless ai-toolkit Qwen Image 2.1 fused-MLP LoRA conversion.
+
+ai-toolkit's Qwen Image 2.1 transformer stores ``gate_up = [gate; up]``;
+Diffusers stores ``gate_layer`` and ``proj`` separately. For a fused update
+``B @ A``, duplicate A and split B's output rows. Rank and scale do not change.
+
+Sources:
+https://github.com/ostris/ai-toolkit/blob/main/extensions_built_in/diffusion_models/qwen_image_2/src/transformer.py
+https://github.com/huggingface/diffusers/blob/85c9fa4caee33d1c5b473395784471d2d7957c1b/src/diffusers/models/transformers/transformer_qwenimage21.py
+
+This deliberately rejects unknown tensors or unmatched modules instead of
+silently loading only the attention part of a checkpoint.
+"""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Mapping
+from typing import Any
+
+
+def convert_angles_state_dict(state_dict: Mapping[str, Any], transformer: Any) -> dict[str, Any]:
+    """Convert A/B-only weights and validate every target against the model.
+
+    The published v2 checkpoint uses PEFT A/B weights without alpha tensors.
+    Its rank/alpha are both 64, hence the effective update is B @ A. An alpha
+    tensor is rejected here so a differently scaled format cannot be mistaken
+    for this one. No adapter tensors are discarded or rescaled.
+    """
+    pairs: dict[str, dict[str, Any]] = {}
+    for key, tensor in state_dict.items():
+        name = key
+        for prefix in ("diffusion_model.", "transformer."):
+            if name.startswith(prefix):
+                name = name[len(prefix):]
+                break
+        suffix = next((s for s in (".lora_A.weight", ".lora_B.weight") if name.endswith(s)), None)
+        if suffix is None or tensor.ndim != 2:
+            raise ValueError(f"Unsupported LoRA tensor: {key}")
+        module_name = name[:-len(suffix)]
+        kind = suffix[6]
+        pair = pairs.setdefault(module_name, {})
+        if kind in pair:
+            raise ValueError(f"Duplicate LoRA tensor: {key}")
+        pair[kind] = tensor
+    if not pairs:
+        raise ValueError("The LoRA checkpoint has no adapter tensors.")
+
+    converted: dict[str, Any] = {}
+
+    def add_pair(module_name: str, a: Any, b: Any) -> None:
+        try:
+            module = transformer.get_submodule(module_name)
+            # Also works when another adapter has already wrapped this Linear.
+            base = module.get_base_layer() if hasattr(module, "get_base_layer") else module
+            expected = tuple(base.weight.shape)
+        except (AttributeError, KeyError) as exc:
+            raise ValueError(f"LoRA targets a missing model module: {module_name}") from exc
+        if len(expected) != 2 or tuple((b.shape[0], a.shape[1])) != expected or b.shape[1] != a.shape[0]:
+            raise ValueError(f"LoRA shape mismatch for {module_name}: A={tuple(a.shape)}, B={tuple(b.shape)}, base={expected}")
+        for kind, tensor in (("A", a), ("B", b)):
+            key = f"transformer.{module_name}.lora_{kind}.weight"
+            if key in converted:
+                raise ValueError(f"Overlapping fused and split LoRA tensors: {key}")
+            converted[key] = tensor
+
+    for name, pair in pairs.items():
+        if set(pair) != {"A", "B"}:
+            raise ValueError(f"Incomplete A/B pair: {name}")
+        a, b = pair["A"], pair["B"]
+        if name.endswith(".img_mlp.gate_up"):
+            if b.shape[0] % 2:
+                raise ValueError(f"Fused gate/up output width must be even: {name}")
+            halfway = b.shape[0] // 2
+            prefix = name[:-len("gate_up")]
+            add_pair(prefix + "gate_layer", a, b[:halfway].contiguous())
+            add_pair(prefix + "proj", a, b[halfway:].contiguous())
+        else:
+            add_pair(name, a, b)
+    return converted
+
+
+def load_angles_adapter(pipe: Any, checkpoint_path: str, *, adapter_name: str = "angles", strength: float = 1.0) -> dict[str, Any]:
+    """Load the complete adapter and verify that every A/B pair was installed.
+
+    Use a fresh adapter name. Conversion and shape checks happen before model
+    mutation. If installation validation fails, remove this adapter and raise.
+    ``strength`` is the sole additional multiplier; rank is never halved when
+    splitting gate/up and no sqrt-rank scaling is introduced.
+    """
+    from safetensors.torch import load_file
+
+    if not math.isfinite(strength) or strength < 0:
+        raise ValueError("Adapter strength must be finite and nonnegative.")
+    if adapter_name in getattr(pipe.transformer, "peft_config", {}):
+        raise ValueError(f"Adapter already exists: {adapter_name}")
+    source = load_file(str(checkpoint_path), device="cpu")
+    weights = convert_angles_state_dict(source, pipe.transformer)
+    expected = {
+        key.removeprefix("transformer.").removesuffix(".lora_A.weight"): tuple(tensor.shape)
+        for key, tensor in weights.items() if key.endswith(".lora_A.weight")
+    }
+    fused_count = sum(key.endswith(".img_mlp.gate_up.lora_A.weight") for key in source)
+    try:
+        pipe.load_lora_weights(weights, adapter_name=adapter_name)
+        for name, a_shape in expected.items():
+            module = pipe.transformer.get_submodule(name)
+            for kind in ("A", "B"):
+                bank = getattr(module, f"lora_{kind}", {})
+                wanted = weights[f"transformer.{name}.lora_{kind}.weight"]
+                if adapter_name not in bank or tuple(bank[adapter_name].weight.shape) != tuple(wanted.shape):
+                    raise RuntimeError(f"Adapter weight was not installed completely: {name}.lora_{kind}")
+            # PEFT must use alpha/rank = 1 before the requested user strength.
+            if module.r[adapter_name] != a_shape[0] or not math.isclose(float(module.scaling[adapter_name]), 1.0):
+                raise RuntimeError(f"Unexpected rank or alpha scaling: {name}")
+        pipe.set_adapters([adapter_name], adapter_weights=[strength])
+    except Exception:
+        if adapter_name in getattr(pipe.transformer, "peft_config", {}):
+            pipe.delete_adapters(adapter_name)
+        raise
+    return {
+        "input_tensors": len(source),
+        "loaded_tensors": len(weights),
+        "fused_mlp_blocks": fused_count,
+        "loaded_modules": len(expected),
+        "ranks": sorted({shape[0] for shape in expected.values()}),
+        "strength": strength,
+    }

app.py

@@ -1,697 +1,127 @@
-"""キャラクター視点シート生成 Space (Qwen-Image-Edit-2511).
-
-設計の要点:
-
-1. カメラは fal/Qwen-Image-Edit-2511-Multiple-Angles-LoRA の構造化トリガで指定する。
-   散文で "Move the camera to a back-facing position..." と書くより再現性が高い。
-
-2. `@spaces.GPU` には **必ず size を明示する**。自動選択には spaces 0.51.1 の
-   バグがあり、48GB の large にモデルが載らず GPU タスクが黙って落ちる (下記 GPU_SIZE)。
-
-3. ZeroGPU のクォータは **要求した duration ぶんそのまま** 消費される
-   (実行時間ではない)。さらに xlarge はその 2 倍が引かれる。そのため
-     - duration を実際の生成枚数から見積もる
-     - 選択内容に応じた推定消費秒数を UI に常時出す
-     - GPU 取得の固定費を何度も払わないよう既定では分割しない
-   という 3 点で無料枠 (300 秒/日) に収める。
-
-4. タグ付けは onnxruntime の CPU 実行にして、クォータを一切消費しない。
-"""
-
-import io
-import os
+"""Character View Sheet: 11 views, optional mannequin guides, PNG-only export."""
+import json
 import random
 import tempfile
-import zipfile
-from typing import Dict, List, Tuple
+import time
+from pathlib import Path
 
 import gradio as gr
-import numpy as np
-import spaces
-import torch
-from diffusers import QwenImageEditPlusPipeline
-from PIL import Image
-
-import tagging
-import views as V
-from framing import crop_framing
-from optimization import apply_fa3_, optimize_pipeline_
-
-# --- モデル読み込み ---------------------------------------------------------
-
-DTYPE = torch.bfloat16
-DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
-
-BASE_MODEL = "Qwen/Qwen-Image-Edit-2511"
-LIGHTNING_REPO = "lightx2v/Qwen-Image-Edit-2511-Lightning"
-LIGHTNING_WEIGHT = "Qwen-Image-Edit-2511-Lightning-4steps-V1.0-bf16.safetensors"
-ANGLES_REPO = "fal/Qwen-Image-Edit-2511-Multiple-Angles-LoRA"
-ANGLES_WEIGHT = "qwen-image-edit-2511-multiple-angles-lora.safetensors"
-
-#: 角度 LoRA の推奨強度は 0.8-1.0。AoTI コンパイル後は実行時に切り替えられないため
-#: 起動時に fuse して固定する。`<sks>` トリガの無いプロンプト (ポーズ生成) への
-#: 副作用が出る場合はこの値を下げる。
-ANGLES_LORA_SCALE = float(os.environ.get("ANGLES_LORA_SCALE", "0.9"))
-
-# LoRA は CPU 上で fuse してから GPU に載せる。
-# (fp8 量子化を CPU 側でやるのは不可。torchao の Float8Tensor が ZeroGPU の
-#  エミュレーション層が使う `aten.empty_like` を実装しておらず、起動時に落ちる。)
-pipe = QwenImageEditPlusPipeline.from_pretrained(BASE_MODEL, torch_dtype=DTYPE)
-
-pipe.load_lora_weights(LIGHTNING_REPO, weight_name=LIGHTNING_WEIGHT, adapter_name="fast")
-pipe.load_lora_weights(ANGLES_REPO, weight_name=ANGLES_WEIGHT, adapter_name="angles")
-pipe.set_adapters(["fast", "angles"], adapter_weights=[1.0, ANGLES_LORA_SCALE])
-pipe.fuse_lora(adapter_names=["fast", "angles"], lora_scale=1.0)
-pipe.unload_lora_weights()
-
-pipe.to(DEVICE)
-
-apply_fa3_(pipe)
-
-# --- AoTI + fp8 は既定で無効 (ENABLE_AOTI=1 で有効化) -----------------------
-#
-# 起動時の AoTI コンパイルは、以前 NVML アサートで失敗していた。原因は後述の
-# GPU_SIZE のバグ (48GB の large にモデルが載らない) と同一で、`optimize_pipeline_`
-# 内の `@spaces.GPU` に size を渡していなかったため。現在は理屈のうえでは
-# size を指定すれば通るはずだが未検証。
-#
-# また現行 ZeroGPU では FA3 のカーネルビルドが無く (kernels が
-# "min() arg is an empty sequence" で失敗)、AoTI 込みの高速化は未確認。
-# 既定は素の bf16。試す場合は Space の Variables に ENABLE_AOTI=1 を設定する。
-if os.environ.get("ENABLE_AOTI", "").strip() in ("1", "true", "True"):
-    # AoTI のグラフ捕捉は **実際の推論と同じ経路** で行う必要がある。
-    # true_cfg_scale を既定 (4.0) のままにすると classifier-free guidance が有効になり、
-    # transformer が cond/uncond の 2 バッチで呼ばれる。バッチ次元は動的次元に
-    # 含めていないため、推論時 (1 バッチ) と形が合わずコンパイル結果が使えなくなる。
-    optimize_pipeline_(
-        pipe,
-        image=[Image.new("RGB", (832, 1216))],
-        prompt="warmup",
-        negative_prompt=" ",
-        height=1216,
-        width=832,
-        num_inference_steps=1,
-        true_cfg_scale=1.0,
-    )
-else:
-    print("[app] AoTI/fp8 は無効 (ENABLE_AOTI=1 で有効化)")
-
-
-MAX_SEED = np.iinfo(np.int32).max
-
-# --- ZeroGPU の duration 見積り ---------------------------------------------
-#
-# ZeroGPU 実測値 (xlarge / MIG 4g.96gb / bf16, 2026-08):
-#   GPU 取得 + モデル転送 : 約 9 秒   (引数なしの selftest が 8.9 秒で完了)
-#   1 枚目 (ウォームアップ込): 4.8 秒
-#   2 枚目以降            : 2.9 秒/枚 (832x1216, 4 step)
-#   4 枚のチャンク合計     : 13.5 秒
-CALL_OVERHEAD_SEC = int(os.environ.get("CALL_OVERHEAD_SEC", "12"))
-PER_VIEW_SEC = int(os.environ.get("PER_VIEW_SEC", "5"))
-
-# 分割は既定で無効 (11 視点なら 1 回の呼び出しに収める)。
-# xlarge はクォータを 2 倍消費するうえ、GPU 取得の固定費が呼び出しごとに
-# かかるため、分割するほど総消費が増える。分割の利点 (残クォータが少なくても
-# 途中まで進める) より、総量を抑えるほうが無料枠では効く。
-# 視点をさらに増やして 1 回では長くなりすぎる場合はここを下げる。
-CHUNK_SIZE = int(os.environ.get("CHUNK_SIZE", "12"))
-
-FREE_QUOTA_SEC = 300  # 無料会員 (ログイン済み)
-ANON_QUOTA_SEC = 120  # 未認証
-
-# --- GPU サイズは明示指定が必須 ---------------------------------------------
-#
-# spaces 0.51.1 のバグ回避。ZeroGPU は起動時に登録テンソル量を測り、
-# Blackwell の閾値 45097156608 (42.0GiB, zero/configs.json) を超えると
-# zero/__init__.py の startup() で _default_gpu_size='xlarge' を立てる。
-# ところが zero/client.py の schedule() は、その既定値を duration の計算には
-# 使うのに、実際の割り当て要求には元の gpu_size=None をそのまま渡してしまう。
-# 結果、本モデル (57.7GB) が 48GB の `large` に転送されて worker が即死し、
-# wrappers.py が res=None を受けて "GPU task aborted" を投げる
-# (デコレート関数に入る前なので Python トレースバックは残らない)。
-#
-# したがって size は自動選択に任せず、必ず明示的に渡すこと。
-# xlarge はクォータを 2 倍消費する。モデルを 42GiB 未満に縮められたら
-# 環境変数 GPU_SIZE=large に戻せる。
-GPU_SIZE = os.environ.get("GPU_SIZE", "xlarge").strip() or "xlarge"
-#: xlarge は要求 duration が内部で 2 倍されてクォータから引かれる
-QUOTA_MULTIPLIER = 2 if GPU_SIZE == "xlarge" else 1
-
-
-def _chunks(items: List, size: int) -> List[List]:
-    return [items[i : i + size] for i in range(0, len(items), size)]
-
-
-def _chunk_duration(payload, *args, **kwargs) -> int:
-    """@spaces.GPU の動的 duration。実際の生成コストぶんだけを要求する。
-
-    寄り視点を「クロップ + 全身」の 2 枚で条件付けすると条件系列が倍になり、
-    実測で 4.6 秒 -> 8.2 秒になる。その分は units に反映されている。
-    """
-    units = sum(item.get("units", 1.0) for item in payload) or 1.0
-    return int(CALL_OVERHEAD_SEC + PER_VIEW_SEC * units)
 
+from backend import MAX_GPU_SECONDS, QUOTA_MULTIPLIER, USE_ANGLES, run_gpu
+from core import build_zip, prepare_reference, requested_seconds
+from pose_guides import ensure_guides, get_guide
+from views import BY_KEY, DEFAULT_KEYS, SIZES, VIEWS, validate_keys
 
-def estimate_quota(
-    selected_keys: List[str], two_stage_prone: bool = False, hq_framing: bool = False
-) -> Tuple[int, int, int]:
-    """(要求秒数の合計, 生成枚数, チャンク数) を返す。"""
-    plan = V.build_plan(selected_keys, two_stage_prone)
-    if not plan:
-        return 0, 0, 0
-    chunks = _chunks(plan, CHUNK_SIZE)
-    total = sum(_chunk_duration([_build_payload(s, "", hq_framing) for s in c]) for c in chunks)
-    return total, len(plan), len(chunks)
+GUIDES = ensure_guides()
 
 
-# --- 生成 -------------------------------------------------------------------
-
-
-@spaces.GPU(duration=_chunk_duration, size=GPU_SIZE)
-def _run_chunk(payload: List[dict], sources: Dict[str, Image.Image], seed: int, steps: int, cfg: float):
-    """1 回の GPU 予約で payload 内の視点をまとめて生成する。
-
-    payload の各要素: {"key", "prompt", "source", "width", "height"}
-    sources: このチャンクが条件付けに使う画像 (key -> PIL)
-    """
-    import time as _time
-
-    t_enter = _time.perf_counter()
-    print(f"[gpu] chunk start: {len(payload)} 枚 / 要求 {_chunk_duration(payload)}秒", flush=True)
-
-    produced: Dict[str, Image.Image] = {}
-    pool = dict(sources)
-
-    for item in payload:
-        src = pool.get(item["source"])
-        if src is None:
-            # GPU 子プロセス側なので gr.Error ではなく素の例外を投げる
-            raise RuntimeError(f"条件画像 {item['source']} が見つかりません")
-
-        # 寄り視点は、条件画像をあらかじめ目的の構図に切り出しておく。
-        # プロンプトだけでは Qwen-Image-Edit が入力のフレーミングを保とうとして
-        # 寄りが効かない (特にカウボーイショット) ことが実測で分かっている。
-        if item.get("crop"):
-            cropped = crop_framing(src, item["crop"], item["width"], item["height"])
-            cond = [cropped, src] if item.get("hq") else [cropped]
-        else:
-            cond = [src]
-
-        t0 = _time.perf_counter()
-        generator = torch.Generator(device=DEVICE).manual_seed(int(seed))
-        image = pipe(
-            image=cond,
-            prompt=item["prompt"],
-            negative_prompt=" ",
-            height=item["height"],
-            width=item["width"],
-            num_inference_steps=steps,
-            generator=generator,
-            true_cfg_scale=cfg,
-            num_images_per_prompt=1,
-        ).images[0]
-        produced[item["key"]] = image
-        pool[item["key"]] = image
-        # アンカー生成がそのまま視点の出力を兼ねている場合、同じチャンク内の
-        # 後続ステップがその視点 key を条件画像として参照することがある
-        # (例: cowboy_front は full_front を切り出す)。ここで別名を張っておかないと
-        # 単一チャンク実行時に条件画像が見つからない。
-        if item.get("alias"):
-            pool[item["alias"]] = image
-        print(
-            f"[gpu]   {item['key']}: {_time.perf_counter() - t0:.1f}秒 "
-            f"({item['width']}x{item['height']}, cond={len(cond)})",
-            flush=True,
-        )
-
-    # 最初の 1 枚までの時間には、ZeroGPU がモデル (57.7GB) を GPU へ転送する
-    # コストが含まれる。チャンクごとに毎回発生するため、duration 見積りの
-    # 固定費 (CALL_OVERHEAD_SEC) はこれを吸収できる値でなければならない。
-    print(f"[gpu] chunk done: {_time.perf_counter() - t_enter:.1f}秒", flush=True)
-    return produced
-
-
-# --- 診断用 -----------------------------------------------------------------
-# "GPU task aborted" が本体コードに到達する前に起きるため、どの段階で壊れているかを
-# 切り分けるための最小テスト。UI の「診断」から実行できる。
-
-
-@spaces.GPU(duration=60, size=GPU_SIZE)
-def gpu_selftest() -> str:
-    """GPU が取得できるか (= 57.7GB のモデル転送が通るか) だけを見る。"""
-    lines = [
-        f"torch={torch.__version__}",
-        f"cuda_available={torch.cuda.is_available()}",
-    ]
-    if torch.cuda.is_available():
-        free, total = torch.cuda.mem_get_info()
-        lines += [
-            f"device={torch.cuda.get_device_name(0)}",
-            f"total={total / 1024**3:.1f}GB",
-            f"free={free / 1024**3:.1f}GB",
-            f"allocated={torch.cuda.memory_allocated() / 1024**3:.1f}GB",
-        ]
-        x = torch.randn(64, 64, device="cuda", dtype=torch.bfloat16)
-        lines.append(f"matmul_ok={bool(torch.isfinite((x @ x).sum()))}")
-    return " | ".join(lines)
-
-
-@spaces.GPU(duration=120, size=GPU_SIZE)
-def gpu_pipe_selftest() -> str:
-    """単純な引数だけで pipe() を 1 回呼ぶ。本体との差は引数の型と呼び出し元だけ。"""
-    t0 = __import__("time").perf_counter()
-    img = pipe(
-        image=[Image.new("RGB", (832, 1216), "white")],
-        prompt="<sks> front view eye-level shot wide shot The background is plain white.",
-        negative_prompt=" ",
-        height=1216,
-        width=832,
-        num_inference_steps=4,
-        generator=torch.Generator(device=DEVICE).manual_seed(0),
-        true_cfg_scale=1.0,
-    ).images[0]
-    dt = __import__("time").perf_counter() - t0
-    return f"ok size={img.size} elapsed={dt:.1f}s peak={torch.cuda.max_memory_allocated() / 1024**3:.1f}GB"
-
-
-def _build_payload(step: V.Step, user_extra: str, hq_framing: bool = False) -> dict:
-    if step.kind == "anchor":
-        prompt = V.anchor_prompt(step.prompt_of, user_extra)
-    else:
-        prompt = V.view_prompt(step.prompt_of, user_extra)
-    hq = bool(step.crop_kind and hq_framing)
-    return {
-        "key": step.key,
-        # アンカーが視点を兼ねる場合の別名。同一チャンク内の後続ステップが
-        # この key で条件画像を引くため、GPU 関数側にも渡す必要がある。
-        "alias": step.view_key if step.kind == "anchor" else "",
-        "prompt": prompt,
-        "source": step.source,
-        "width": step.size[0],
-        "height": step.size[1],
-        "crop": step.crop_kind,
-        "hq": hq,
-        # 2 枚条件付けは実測で約 1.8 倍の時間がかかる
-        "units": 1.8 if hq else 1.0,
-    }
-
-
-def _gallery_items(images: Dict[str, Image.Image], selected: List[str]) -> List[Tuple[Image.Image, str]]:
-    items = []
-    for key in selected:
-        img = images.get(key)
-        if img is not None:
-            items.append((img, V.VIEW_BY_KEY[key].label_ja))
-    return items
-
-
-def generate(
-    image,
-    selected_keys: List[str],
-    extra_prompt: str,
-    trigger_word: str,
-    exclude_tags: str,
-    tagger_choice: str,
-    wd_threshold: float,
-    oppai_threshold: float,
-    seed: int,
-    randomize_seed: bool,
-    true_guidance_scale: float,
-    num_inference_steps: int,
-    two_stage_prone: bool,
-    hq_framing: bool,
-):
-    """チャンクごとに GPU を取り直しながら生成し、途中経過��随時 yield する。
-
-    ジェネレータ自体は GPU 関数ではない。GPU を掴むのは `_run_chunk` だけで、
-    1 回あたりの要求 duration を小さく保つことでクォータ不足による門前払いを避ける。
-    """
-    if image is None:
-        raise gr.Error("入力画像をアップロードしてください")
-    if not selected_keys:
-        raise gr.Error("視点を 1 つ以上選択してください")
-
-    if randomize_seed:
-        seed = random.randint(0, MAX_SEED)
-
-    reference = image.convert("RGB") if isinstance(image, Image.Image) else Image.open(image).convert("RGB")
-
-    plan = V.build_plan(selected_keys, two_stage_prone)
-    chunks = _chunks(plan, CHUNK_SIZE)
-    total_req, n_gen, n_chunks = estimate_quota(selected_keys, two_stage_prone, hq_framing)
-
-    images: Dict[str, Image.Image] = {"reference": reference}
-    done = 0
-
-    yield (
-        [],
-        gr.DownloadButton(value=None, interactive=False),
-        seed,
-        f"生成開始: {n_gen} 枚 / {n_chunks} 回に分割 / 要求 {total_req} 秒",
-        "",
+def allocation_message(keys):
+    if not keys:
+        return "視点を選択してください。"
+    allocation = requested_seconds(keys, MAX_GPU_SECONDS)
+    quota = allocation * QUOTA_MULTIPLIER
+    message = (
+        f"選択: {len(set(keys))}視点。1回のGPU時間枠は最大{allocation}秒"
+        f"（利用枠への換算: {quota}秒）。\n\n"
+        "未ログインの1日枠は120秒です。他のZeroGPU利用分と共有されます。"
+        "11視点の完成時間は設定や混雑で変わります。余裕がなくなったら、完成済み画像を返します。"
     )
-
-    for ci, chunk in enumerate(chunks, start=1):
-        payload = [_build_payload(s, extra_prompt, hq_framing) for s in chunk]
-        needed = {p["source"] for p in payload}
-        sources = {k: v for k, v in images.items() if k in needed}
-
-        labels = " / ".join(s.label_ja for s in chunk)
-        yield (
-            _gallery_items(images, selected_keys),
-            gr.DownloadButton(value=None, interactive=False),
-            seed,
-            f"[{ci}/{n_chunks}] 生成中: {labels}",
-            "",
-        )
-
-        produced = _run_chunk(payload, sources, int(seed), int(num_inference_steps), float(true_guidance_scale))
-        images.update(produced)
-
-        # アンカー生成がそのまま視点の出力を兼ねている場合はここで別名を張る
-        for s in chunk:
-            if s.kind == "anchor" and s.view_key:
-                images[s.view_key] = images[s.key]
-
-        done += len(chunk)
-        yield (
-            _gallery_items(images, selected_keys),
-            gr.DownloadButton(value=None, interactive=False),
-            seed,
-            f"[{ci}/{n_chunks}] 完了 ({done}/{n_gen} 枚)",
-            "",
-        )
-
-    # --- ここから CPU 処理 (ZeroGPU クォータを消費しない) ---
-    yield (
-        _gallery_items(images, selected_keys),
-        gr.DownloadButton(value=None, interactive=False),
-        seed,
-        "キャプションを生成中 (CPU)...",
-        "",
-    )
-
-    want = {"WD Tagger v3": ["wd"], "OppaiOracle V1.1": ["oppai"], "両方 (比較する)": ["wd", "oppai"]}
-    active = want.get(tagger_choice, [])
-    thresholds = {"wd": wd_threshold, "oppai": oppai_threshold}
-
-    per_view: Dict[str, Dict[str, tagging.TagResult]] = {}
-    for key in selected_keys:
-        img = images.get(key)
-        if img is None:
-            continue
-        per_view[key] = {}
-        for name in active:
-            try:
-                per_view[key][name] = tagging.TAGGERS[name].predict(img, thresholds[name])
-            except Exception as exc:  # noqa: BLE001 - タグ付け失敗で生成物を捨てない
-                print(f"[app] タガー {name} が失敗: {exc}")
-
-    primary = active[0] if active else None
-    alt = active[1] if len(active) > 1 else None
-
-    zip_path = _build_zip(images, selected_keys, per_view, primary, alt, trigger_word, exclude_tags)
-    report = tagging.comparison_markdown(per_view) if (per_view and alt) else ""
-
-    yield (
-        _gallery_items(images, selected_keys),
-        gr.DownloadButton(value=zip_path, interactive=True),
-        seed,
-        f"完了: {len(per_view)} 視点 / 要求クォータ 合計 {total_req} 秒 (seed {seed})",
-        report,
-    )
-
-
-def _build_zip(
-    images: Dict[str, Image.Image],
-    selected_keys: List[str],
-    per_view: Dict[str, Dict[str, tagging.TagResult]],
-    primary: str,
-    alt: str,
-    trigger_word: str,
-    exclude_tags: str,
-) -> str:
-    """kohya-ss にそのまま食わせられる構成で ZIP を作る。
-
-        dataset/NN_key.png + NN_key.txt   <- 主タガーのキャプション
-        captions_alt/NN_key.txt           <- 比較用のもう一方
-        caption_comparison.md
-    """
-    exclude = tagging.parse_exclude(exclude_tags)
-    tmp_dir = tempfile.mkdtemp()
-    zip_path = os.path.join(tmp_dir, "character_views.zip")
-
-    with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf:
-        for i, key in enumerate(selected_keys, start=1):
-            img = images.get(key)
-            if img is None:
-                continue
-            base = f"{i:02d}_{key}"
-
-            buf = io.BytesIO()
-            img.convert("RGB").save(buf, format="PNG")
-            zf.writestr(f"dataset/{base}.png", buf.getvalue())
-
-            fixed = V.caption_tags(V.VIEW_BY_KEY[key])
-            results = per_view.get(key, {})
-
-            if primary:
-                predicted = results[primary].names() if primary in results else []
-                zf.writestr(
-                    f"dataset/{base}.txt",
-                    tagging.build_caption(fixed, predicted, trigger_word, exclude),
-                )
-            else:
-                # タガーを使わない場合でも構図タグだけのキャプションは出しておく
-                zf.writestr(
-                    f"dataset/{base}.txt",
-                    tagging.build_caption(fixed, [], trigger_word, exclude),
-                )
-
-            if alt and alt in results:
-                zf.writestr(
-                    f"captions_alt/{base}.txt",
-                    tagging.build_caption(fixed, results[alt].names(), trigger_word, exclude),
-                )
-
-        if per_view and alt:
-            zf.writestr("caption_comparison.md", tagging.comparison_markdown(per_view))
-
-    return zip_path
-
-
-# --- UI ---------------------------------------------------------------------
-
-CSS = """
-#col-container {margin: 0 auto; max-width: 1400px;}
-.notice {
-  background: #fff5f5; border: 1px solid #fca5a5; color: #7f1d1d;
-  padding: 12px 14px; border-radius: 10px; font-weight: 600;
-  line-height: 1.5; margin-bottom: 10px;
-}
-.quota {
-  background: #f0f9ff; border: 1px solid #7dd3fc; color: #0c4a6e;
-  padding: 10px 14px; border-radius: 10px; line-height: 1.6;
-}
-"""
-
-
-def quota_markdown(*group_values) -> str:
-    selected = [k for group in group_values[:-2] for k in group]
-    two_stage = bool(group_values[-2])
-    hq = bool(group_values[-1])
-    requested, n_gen, n_chunks = estimate_quota(selected, two_stage, hq)
-    if not n_gen:
-        return "<div class='quota'>視点が選択されていません。</div>"
-
-    # xlarge は要求 duration が内部で 2 倍されてクォータから引かれる
-    total = requested * QUOTA_MULTIPLIER
-
-    def verdict(limit: int) -> str:
-        if total <= limit:
-            return f"✅ {limit}秒以内 (残り {limit - total}秒)"
-        return f"❌ {total - limit}秒 超過"
-
-    extra = ""
-    if n_gen > len(selected):
-        extra = (
-            f"<br><small>※ 生成 {n_gen} 枚のうち {n_gen - len(selected)} 枚は、"
-            "寄りの切り出し元やポーズ基準として必要な中間生成です。</small>"
-        )
-
-    size_note = (
-        f" <small>(GPU size <code>{GPU_SIZE}</code> のため要求 {requested} 秒 × 2)</small>"
-        if QUOTA_MULTIPLIER > 1
-        else ""
-    )
-    return (
-        "<div class='quota'>"
-        f"<b>推定 ZeroGPU 消費: {total} 秒</b>{size_note} "
-        f"({len(selected)} 視点 / 生成 {n_gen} 枚 / {n_chunks} 回に分割)<br>"
-        f"無料会員 (300秒/日): {verdict(FREE_QUOTA_SEC)}<br>"
-        f"未認証 (120秒/日): {verdict(ANON_QUOTA_SEC)}"
-        f"{extra}"
-        "</div>"
-    )
-
-
-with gr.Blocks(css=CSS) as demo:
-    gr.Markdown("# キャラクター視点シート生成 (Qwen-Image-Edit-2511 + 角度LoRA)")
+    if quota > 120:
+        message += "\n\n現在のGPU設定では未ログインの1日枠を超えます。"
+    return message
+
+
+def pose_preview(keys):
+    return [(str(GUIDES[key]), BY_KEY[key].label) for key in (keys or []) if key in BY_KEY]
+
+
+def generate(reference, keys, pose_enabled, resolution, extra, seed, random_seed, crop_close_views=False):
+    # Invalid retry inputs must not leave a previous character's ZIP visible.
+    yield [], None, None, "入力を確認しています。", seed
+    if reference is None:
+        raise gr.Error("キャラクターの参照画像をアップロードしてください。")
+    try:
+        keys = validate_keys(keys)
+    except ValueError as exc:
+        raise gr.Error(str(exc)) from exc
+    if resolution not in SIZES:
+        raise gr.Error("解像度を選択してください。")
+    seed = random.randint(0, 2**31 - 1) if random_seed else int(seed)
+    reference = prepare_reference(reference, 768 if resolution == "fast" else 1216)
+    guides = None
+    if pose_enabled:
+        guides = {key: get_guide(key, *SIZES[resolution][BY_KEY[key].shape]) for key in keys}
+
+    # Clear stale downloads and results before requesting GPU time.
+    yield [], None, None, "生成中です。", seed
+    started = time.perf_counter()
+    try:
+        images, reason, metrics = run_gpu(reference, keys, guides, resolution, seed, extra or "", crop_close_views)
+    except Exception as exc:
+        print(f"[app] GPU request failed: {type(exc).__name__}: {exc}", flush=True)
+        # Keep infrastructure quota errors visible; no invented successful result.
+        yield [], None, None, f"生成できませんでした: {exc}", seed
+        return
+    metrics["request_wall_seconds"] = round(time.perf_counter() - started, 3)
+    gallery = [(images[key], BY_KEY[key].label) for key in keys if key in images]
+    status = f"{len(images)}/{len(keys)}視点を生成しました。Seed: {seed}"
+    if reason:
+        status += "\n" + reason
+    # Gradio caches yielded files before requesting the next generator item.
+    # Keep originals alive across this yield, then remove both report and ZIP.
+    with tempfile.TemporaryDirectory(prefix="view-result-") as result_dir:
+        report = Path(result_dir) / "generation_metrics.json"
+        report.write_text(json.dumps(metrics, ensure_ascii=False, indent=2), encoding="utf-8")
+        archive = build_zip(images, keys, output_dir=result_dir)
+        yield gallery, archive, str(report), status, seed
+
+
+with gr.Blocks(title="Character View Sheet (Qwen Image 2.1 turbo)", delete_cache=(3600, 3600)) as demo:
+    gr.Markdown("# Character View Sheet (Qwen Image 2.1 turbo)\n参照画像とポーズ人形から、学習用の11視点を生成します。")
     gr.Markdown(
-        "参照画像 1 枚から、LoRA 学習用の視点セットを生成します。"
-        "カメラ位置は `fal/Qwen-Image-Edit-2511-Multiple-Angles-LoRA` の"
-        "96 カメラ位置から指定しているため、散文プロンプトより構図が安定します。\n\n"
-        "💡 **ZeroGPU のクォータは「要求した秒数」がそのまま引かれます** "
-        "(実行時間ではありません)。不要な視点のチェックを外すほど 1 回の要求が小さくなり、"
-        "無料枠で通りやすくなります。生成は自動で複数回に分割されるため、"
-        "途中でクォータが尽きてもそこまでの結果は残ります。"
+        "**研究用デモ** · 多視点生成の速度・人物同一性・ポーズ追従を評価するための試作です。"
+        "利用モデルのライセンスは "
+        "[Qwen Research License](https://huggingface.co/Qwen/Qwen-Image-2.1-Turbo/blob/main/LICENSE)です。"
+        "商用利用は別許諾が必要です。生成画像から学習したモデルを配布・提供する場合、"
+        "関連文書に「Built with Qwen」または「Improved using Qwen」の表示条件があります。"
     )
-
-    with gr.Column(elem_id="col-container"):
-        gr.HTML(
-            "<div class='notice'>"
-            "注意：他者が作成した画像のアップロードはご遠慮ください。"
-            "他人の著作物・肖像権を侵害する恐れがあります。"
-            "当アプリ作成者は、アップロード内容による権利侵害について一切の責任を負いません。"
-            "</div>"
-        )
-
-        with gr.Row():
-            with gr.Column(scale=1):
-                input_image = gr.Image(label="入力画像 (参照キャラクター)", type="pil", height=420)
-                extra_prompt = gr.Textbox(
-                    label="追加プロンプト (全視点の末尾に追記)",
-                    placeholder="例: anime style, soft lighting, pastel colors",
-                    lines=2,
-                )
-
-            with gr.Column(scale=1):
-                gr.Markdown("### 生成する視点")
-                group_boxes = []
-                for group in V.GROUP_ORDER:
-                    members = [v for v in V.VIEWS if v.group_ja == group]
-                    group_boxes.append(
-                        gr.CheckboxGroup(
-                            label=group,
-                            choices=[(v.label_ja, v.key) for v in members],
-                            value=[v.key for v in members],
-                        )
-                    )
-                with gr.Row():
-                    preset_buttons = [gr.Button(name, size="sm") for name in V.PRESETS]
-                hq_framing = gr.Checkbox(
-                    label="寄り視点を高品質モードで生成 (時間 約1.8倍)",
-                    value=False,
-                    info="顔・上半身・カウボーイを「クロップ + 全身」の2枚で条件付けします。"
-                         "情報量が増えて精細になりますが、要求クォータも増えます。",
-                )
-                quota_box = gr.HTML(value=quota_markdown(*[[v.key for v in V.VIEWS], False, False]))
-
-        run_button = gr.Button("🎨 生成", variant="primary")
-        status_text = gr.Textbox(label="ステータス", interactive=False)
-        gallery = gr.Gallery(
-            label="生成結果", columns=4, height=620, object_fit="contain", show_download_button=True
-        )
-        download_btn = gr.DownloadButton(
-            label="📦 学習用データセット (画像 + キャプション) を ZIP でダウンロード",
-            value=None,
-            variant="secondary",
-            interactive=False,
-        )
-
-        with gr.Accordion("🏷️ キャプション設定 (LoRA 学習用)", open=True):
-            gr.Markdown(
-                "タグ付けは **CPU (onnxruntime)** で実行するため ZeroGPU のクォータを消費しません。\n\n"
-                "構図タグ (`full body` / `from behind` / `from above` / `cowboy shot` など) は"
-                "カメラ設定から**決定的に注入**しています。タガーは構図を安定して当てられないためです。"
-            )
-            with gr.Row():
-                trigger_word = gr.Textbox(
-                    label="トリガーワード (全キャプションの先頭に付与)",
-                    placeholder="例: mychar",
-                )
-                exclude_tags = gr.Textbox(
-                    label="除外タグ (カンマ区切り)",
-                    placeholder="例: black hair, blue eyes  ← LoRA に焼き込みたい特徴を外す",
-                )
-            tagger_choice = gr.Radio(
-                label="使用するタガー",
-                choices=["WD Tagger v3", "OppaiOracle V1.1", "両方 (比較する)"],
-                value="両方 (比較する)",
+    with gr.Row():
+        with gr.Column():
+            reference = gr.Image(label="キャラクターの参照画像", type="pil", height=380)
+            pose_enabled = gr.Checkbox(label="ポーズ人形を参照する", value=True)
+            crop_close_views = gr.Checkbox(label="白背景の直立全身画像：顔・上半身用に切り出す", value=False)
+            gr.Markdown("切り出しは実験機能です。構図が改善する一方、衣装の形が変わる場合があります。")
+            gr.Markdown("人形の姿勢・向き・構図を参考にします。関節位置を厳密に固定する機能ではありません。")
+            extra = gr.Textbox(label="追加の指示", placeholder="例: 元画像の線画と塗り方を維持", lines=2, max_lines=4)
+        with gr.Column():
+            keys = gr.CheckboxGroup(label="生成する視点", choices=[(v.label, v.key) for v in VIEWS], value=DEFAULT_KEYS)
+            resolution = gr.Radio(
+                label="画像サイズ", choices=[("高速: 全身512×768・寄り640×640", "fast"),
+                                              ("標準・速度優先: 全身832×1216・寄り1024×1024", "balanced"),
+                                              ("標準・細部優先: 全身832×1216・寄り1024×1024", "standard")],
+                value="balanced",
             )
-            with gr.Row():
-                wd_threshold = gr.Slider(
-                    label="WD Tagger 閾値",
-                    minimum=tagging.WDTagger.threshold_range[0],
-                    maximum=tagging.WDTagger.threshold_range[1],
-                    step=tagging.WDTagger.threshold_range[2],
-                    value=tagging.WD_DEFAULT_THRESHOLD,
-                )
-                oppai_threshold = gr.Slider(
-                    label="OppaiOracle 閾値 (WD よりスコア分布が高い)",
-                    minimum=tagging.OppaiOracleTagger.threshold_range[0],
-                    maximum=tagging.OppaiOracleTagger.threshold_range[1],
-                    step=tagging.OppaiOracleTagger.threshold_range[2],
-                    value=tagging.OPPAI_DEFAULT_THRESHOLD,
-                )
-            comparison_md = gr.Markdown(label="タガー比較")
-
-        with gr.Accordion("⚙️ 詳細設定", open=False):
-            seed = gr.Slider(label="Seed", minimum=0, maximum=MAX_SEED, step=1, value=0)
-            randomize_seed = gr.Checkbox(label="ランダムシード", value=True)
-            true_guidance_scale = gr.Slider(
-                label="True guidance scale", minimum=1.0, maximum=10.0, step=0.1, value=1.0
-            )
-            num_inference_steps = gr.Slider(
-                label="生成ステップ数 (Lightning LoRA 前提で 4 推奨)",
-                minimum=1, maximum=40, step=1, value=4,
-            )
-            gr.Markdown("#### 診断")
-            with gr.Row():
-                selftest_btn = gr.Button("GPU 取得テスト", size="sm")
-                pipetest_btn = gr.Button("pipe() 単発テスト", size="sm")
-            selftest_out = gr.Textbox(label="診断結果", interactive=False)
-
-            two_stage_prone = gr.Checkbox(
-                label="うつ伏せを 2 段階で生成する (品質優先 / 生成 +1 枚)",
-                value=False,
-                info="ポーズ変更とカメラ移動を分けます。1 段階で破綻する場合に有効化してください。",
-            )
-
-    selftest_btn.click(fn=gpu_selftest, inputs=None, outputs=selftest_out)
-    pipetest_btn.click(fn=gpu_pipe_selftest, inputs=None, outputs=selftest_out)
-
-    # --- イベント ---
-    quota_inputs = group_boxes + [two_stage_prone, hq_framing]
-    for comp in quota_inputs:
-        comp.change(fn=quota_markdown, inputs=quota_inputs, outputs=quota_box)
-
-    for button, preset_name in zip(preset_buttons, V.PRESETS):
-        keys = V.PRESETS[preset_name]
-
-        def _apply(keys=keys):
-            return [
-                gr.CheckboxGroup(value=[v.key for v in V.VIEWS if v.group_ja == g and v.key in keys])
-                for g in V.GROUP_ORDER
-            ]
-
-        button.click(fn=_apply, inputs=None, outputs=group_boxes).then(
-            fn=quota_markdown, inputs=quota_inputs, outputs=quota_box
-        )
-
-    def _collect_and_generate(image, *args):
-        n_groups = len(V.GROUP_ORDER)
-        selected = [k for group in args[:n_groups] for k in group]
-        yield from generate(image, selected, *args[n_groups:])
-
-    run_button.click(
-        fn=_collect_and_generate,
-        inputs=[input_image, *group_boxes, extra_prompt, trigger_word, exclude_tags,
-                tagger_choice, wd_threshold, oppai_threshold, seed, randomize_seed,
-                true_guidance_scale, num_inference_steps, two_stage_prone, hq_framing],
-        outputs=[gallery, download_btn, seed, status_text, comparison_md],
-    )
-
+            allocation = gr.Markdown(allocation_message(DEFAULT_KEYS))
+    with gr.Accordion("ポーズ人形を確認", open=False):
+        previews = gr.Gallery(value=pose_preview(DEFAULT_KEYS), columns=4, height=430,
+                              label="ポーズ参照", object_fit="contain", interactive=False)
+    with gr.Accordion("Seed設定", open=False):
+        seed = gr.Number(label="Seed", value=0, precision=0, minimum=0, maximum=2**31 - 1)
+        random_seed = gr.Checkbox(label="ランダムSeed", value=True)
+    run = gr.Button("選択した視点を生成", variant="primary")
+    status = gr.Textbox(label="進行状況", interactive=False)
+    results = gr.Gallery(label="生成した画像", columns=4, height=580, object_fit="contain")
+    download = gr.File(label="画像だけのZIP", interactive=False)
+    with gr.Accordion("実行時間の記録", open=False):
+        report = gr.File(label="計測結果 JSON", interactive=False)
+        gr.Markdown("高速化の確認用です。画像ZIPには画像だけが入ります。")
+    if USE_ANGLES:
+        gr.Markdown("2.1用角度LoRAを併用した実験設定です。")
+
+    keys.change(fn=allocation_message, inputs=keys, outputs=allocation, queue=False)
+    keys.change(fn=pose_preview, inputs=keys, outputs=previews, queue=False)
+    run.click(generate, [reference, keys, pose_enabled, resolution, extra, seed, random_seed, crop_close_views],
+              [results, download, report, status, seed], concurrency_limit=1, concurrency_id="generation")
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.queue(max_size=8, default_concurrency_limit=1).launch(max_file_size="20mb")

backend.py

@@ -0,0 +1,92 @@
+"""Turbo workflow verified on local CUDA and Hugging Face ZeroGPU large."""
+import os
+import time
+
+import spaces
+import torch
+from diffusers import QwenImage21Pipeline
+from huggingface_hub import hf_hub_download
+
+from core import requested_seconds, run_batch, rgb_on_white
+from angles_adapter import load_angles_adapter
+from views import REFERENCE_RESOLUTION
+
+MODEL_ID = "Qwen/Qwen-Image-2.1-Turbo"
+MODEL_REVISION = "d65dbc9a7e8f6b5479e33dee6030eaab2a906509"
+GPU_SIZE = os.getenv("GPU_SIZE", "large")
+if GPU_SIZE not in ("large", "xlarge"):
+    raise ValueError("GPU_SIZE must be large or xlarge")
+QUOTA_MULTIPLIER = 2 if GPU_SIZE == "xlarge" else 1
+MAX_GPU_SECONDS = int(os.getenv("MAX_GPU_SECONDS", "110"))
+if not 45 <= MAX_GPU_SECONDS <= 110:
+    raise ValueError("MAX_GPU_SECONDS must be between 45 and 110")
+STARTUP_RESERVE_SECONDS = 15
+USE_ANGLES = os.getenv("ENABLE_ANGLES_LORA", "0") == "1"
+ANGLES_REPO = "akhaliq/Qwen-Image-2.1-Multiple-Angles-LoRA"
+ANGLES_WEIGHT = ("checkpoints_v2/angles_v2_full_qwen21_multiple_angles_v2_"
+                 "qwen21_multiple_angles_v2_000001500.safetensors")
+
+# ZeroGPU requires startup CUDA placement, not moving the model for each request.
+# Do not reuse the old 2511 Lightning or angles adapters on this architecture.
+pipe = QwenImage21Pipeline.from_pretrained(
+    MODEL_ID, revision=MODEL_REVISION, dtype=torch.bfloat16,
+)
+if USE_ANGLES:
+    checkpoint = hf_hub_download(ANGLES_REPO, filename=ANGLES_WEIGHT)
+    print(load_angles_adapter(pipe, checkpoint, adapter_name="angles", strength=0.8))
+    pipe.fuse_lora(adapter_names=["angles"])
+    pipe.unload_lora_weights()
+pipe.vae.enable_tiling()
+pipe.to("cuda")
+if len(pipe.config.get("sample_sigmas", [])) != 8:
+    raise RuntimeError("Turboの8-stepスケジュールを読み込めていません。Diffusersのバージョンを確認してください。")
+
+
+def duration(reference, keys, guides, resolution, seed, extra, crop_close_views=False):
+    return requested_seconds(keys, MAX_GPU_SECONDS)
+
+
+@spaces.GPU(duration=duration, size=GPU_SIZE)
+def run_gpu(reference, keys, guides, resolution, seed, extra, crop_close_views=False):
+    started = time.perf_counter()
+    torch.cuda.reset_peak_memory_stats()
+
+    def generate_one(*, image, prompt, width, height, seed, check_budget):
+        def callback(pipeline, step, timestep, callback_kwargs):
+            check_budget()
+            return callback_kwargs
+
+        output = pipe(
+            image=image,
+            prompt=prompt,
+            width=width,
+            height=height,
+            # Also bounds the area used to encode EACH reference; reducing only
+            # PIL input dimensions does not avoid the pipeline's internal upscaling.
+            output_resolution=REFERENCE_RESOLUTION[resolution],
+            true_cfg_scale=1.0,
+            use_kv_cache=True,
+            num_images_per_prompt=1,
+            generator=torch.Generator("cpu").manual_seed(seed),
+            callback_on_step_end=callback,
+        ).images[0]
+        return rgb_on_white(output)
+
+    allocation = duration(reference, keys, guides, resolution, seed, extra)
+    result = run_batch(
+        generate_one, reference, keys, guides, resolution, seed, extra, USE_ANGLES,
+        budget_seconds=allocation - STARTUP_RESERVE_SECONDS,
+        crop_close_views=crop_close_views,
+    )
+    metrics = {
+        "model": MODEL_ID, "revision": MODEL_REVISION, "gpu": torch.cuda.get_device_name(),
+        "gpu_size": GPU_SIZE, "reserved_seconds": allocation,
+        "quota_budget_seconds": allocation * QUOTA_MULTIPLIER,
+        "gpu_function_seconds": round(time.perf_counter() - started, 3),
+        "peak_allocated_gib": round(torch.cuda.max_memory_allocated() / 1024**3, 2),
+        "resolution": resolution, "pose_guides": guides is not None, "angles_lora": USE_ANGLES,
+        "crop_close_views": crop_close_views,
+        "seed": int(seed), "requested_views": keys, "completed_views": list(result.images),
+        "timings": result.timings, "stop_reason": result.stop_reason,
+    }
+    return result.images, result.stop_reason, metrics

bench/README.md

@@ -1,102 +0,0 @@
----
-title: Krea2 vs Qwen-Image-Edit Benchmark
-emoji: ⏱️
-colorFrom: yellow
-colorTo: red
-sdk: gradio
-sdk_version: 5.49.1
-app_file: app.py
-pinned: false
-license: apache-2.0
-short_description: Krea 2 Turbo と Qwen-Image-Edit-2511 の生成時間・VRAM を実測比較
----
-
-# Krea 2 Turbo vs Qwen-Image-Edit-2511 ベンチマーク
-
-**これは別 Space として公開するためのディレクトリ。** メインの
-`Qwen-Image-Edit-2511-Lora-Sheet` とは独立した Space リポジトリに push すること。
-
-```bash
-# 例
-huggingface-cli repo create Krea2-vs-Qwen-Edit-Bench --type space --sdk gradio
-cd bench && git init && git remote add origin https://huggingface.co/spaces/<user>/Krea2-vs-Qwen-Edit-Bench
-git add . && git commit -m "init" && git push -u origin main
-```
-
-> ⚠️ **無料アカウントがホストできる ZeroGPU Space は最大 2 つ。**
-> メインの Space と合わせてちょうど上限に達する。
-
-## 何を測るか
-
-- 1 枚あたりの生成時間 (cold = 初回 / warm = 2 回目以降の中央値)
-- ピーク VRAM (`torch.cuda.max_memory_allocated`)
-- 同一 seed・同一解像度での出力画像
-
-## 公平性についての注記
-
-**同一ワークロードの比較ではない。**
-
-| | Krea 2 Turbo | Qwen-Image-Edit-2511 |
-|---|---|---|
-| stock diffusers での用途 | text-to-image のみ | 画像編集 (i2i, 多画像入力可) |
-| パイプライン | `Krea2Pipeline` | `QwenImageEditPlusPipeline` |
-| ステップ | 8 (TDM 蒸留), guidance 0.0 | 4 (Lightning LoRA), true_cfg 1.0 |
-
-Krea 2 には「参照画像 1 枚から同一キャラの多視点を派生させる」機能が公式に存在しない。
-そのため本ベンチは**各モデルが本来の用途を実行したときのコスト**を並べている。
-
-## VRAM と ZeroGPU サイズ
-
-bf16 での重みは概算で
-
-- Qwen-Image-Edit-2511: transformer 40.9GB + text encoder (Qwen2.5-VL-7B) 16.6GB ≈ **57GB**
-- Krea 2 Turbo: transformer ~24GB + text encoder (Qwen3-VL-4B) ~8GB ≈ **32GB**
-
-合計 89GB となり、ZeroGPU の `large` (48GB) はもちろん `xlarge` (96GB) でも
-活性値を含めると危うい。既定では**両モデルとも fp8 量子化**し `size="xlarge"` で動かす。
-
-> `xlarge` はクォータを **2 倍**消費する。片方だけを正確に測るなら `BENCH_MODELS` で
-> 絞ること (1 モデルなら `large` に収まり消費も半分になる)。
-
-## 環境変数
-
-| 変数 | 既定 | 意味 |
-|---|---|---|
-| `BENCH_MODELS` | `both` | `both` / `qwen` / `krea` |
-| `BENCH_FP8` | `1` | `0` で bf16 のまま |
-| `BENCH_SIZE` | `xlarge` | ZeroGPU の GPU サイズ |
-| `KREA_REPO` | (なし) | Krea 2 の取得元を明示指定 |
-
-## Krea 2 の取得について
-
-本家 [`krea/Krea-2-Turbo`](https://huggingface.co/krea/Krea-2-Turbo) は **gated (auto)**。
-Space の Settings で `HF_TOKEN` シークレットを設定し、モデルページで利用規約に同意しておく。
-それを避けたい場合は非 gated のミラー (`unsloth/Krea-2-Turbo` /
-`CalamitousFelicitousness/Krea-2-Turbo-Diffusers`) が自動でフォールバック候補になる。
-
-### ライセンス上の注意
-
-Krea 2 Community License は、**モデルをホストする側に入出力のセーフティ分類器の実装**を
-求めている (NCII / CSAM 等の生成防止)。また無償の商用利用は年商 $1M 未満かつ 50 席未満に限られる。
-
-このベンチ Space はユーザーの画像アップロードを受け付けるため、**公開運用するなら
-この要件を検討する必要がある**。計測目的に限るなら Space を private にするのが安全。
-
-Qwen-Image-Edit-2511 は Apache-2.0 で、この種の義務はない。
-
-## Krea 2 の identity 編集を比較したい場合
-
-Krea 2 で「参照画像の同一性を保った編集」を試すには、以下のいずれかが必要:
-
-1. ComfyUI + [`conradlocke/krea2-identity-edit`](https://huggingface.co/conradlocke/krea2-identity-edit)
-   + 専用ノードパック `ComfyUI-Krea2Edit` (標準ノードでは扱えない dual conditioning を使うため)
-2. 非公式の diffusers 移植
-   [`huan-yin/Krea2-Identity-Edit-Diffusers`](https://github.com/huan-yin/Krea2-Identity-Edit-Diffusers)
-   (`trust_remote_code=True`, 10 step, `ref_boost` 既定 4.0)
-
-いずれも公式サポート外で、元 LoRA のダウンロード実績もほぼ無い。モデルカード自身が
-「特徴的な顔の骨格には弱い」「衣装の入れ替えは安定しない」と明記しており、
-多視点にわたる同一性維持という用途では不利。
-
-Space のビルドを壊すリスクがあるため `requirements.txt` には含めていない。
-試す場合は手動で追加すること。

bench/app.py

@@ -1,288 +0,0 @@
-"""Krea 2 Turbo vs Qwen-Image-Edit-2511 の実測ベンチマーク Space.
-
-測るもの:
-  - 1 枚あたりの生成時間 (cold = 初回, warm = 2 回目以降の中央値)
-  - ピーク VRAM (torch.cuda.max_memory_allocated)
-  - 同一 seed / 同一解像度での出力画像
-
-**公平性についての注記**: この 2 つは同じ土俵に乗らない。
-Krea 2 Turbo は text-to-image 専用 (stock diffusers に編集パイプラインが無い)、
-Qwen-Image-Edit-2511 は画像編集モデルである。そのため
-「それぞれが本来の用途を実行したときのコスト」を測る形にしてある。
-同一ワークロードの比較ではないので、表を読むときは注意すること。
-
-VRAM について:
-  bf16 では Qwen 約 57GB + Krea2 約 32GB = 89GB となり、ZeroGPU の
-  `large` (48GB) はもちろん `xlarge` (96GB) でも活性値を含めると危うい。
-  既定では両モデルとも fp8 量子化し、`size="xlarge"` で動かす。
-  片方だけを正確に測りたい場合は環境変数 BENCH_MODELS で絞ること
-  (1 モデルなら `large` に収まり、クォータ消費も半分になる)。
-
-環境変数:
-  BENCH_MODELS  "both" (既定) | "qwen" | "krea"
-  BENCH_FP8     "1" (既定) で fp8 量子化。"0" で bf16
-  BENCH_SIZE    "xlarge" (既定) | "large"   ZeroGPU の GPU サイズ
-  KREA_REPO     Krea 2 の取得元を上書き
-"""
-
-import os
-import statistics
-import time
-from typing import Dict, List, Optional
-
-import gradio as gr
-import spaces
-import torch
-from PIL import Image
-
-MODELS = os.environ.get("BENCH_MODELS", "both").lower()
-USE_FP8 = os.environ.get("BENCH_FP8", "1") not in ("0", "false", "False")
-GPU_SIZE = os.environ.get("BENCH_SIZE", "xlarge")
-
-DTYPE = torch.bfloat16
-DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
-
-QWEN_REPO = "Qwen/Qwen-Image-Edit-2511"
-QWEN_LIGHTNING_REPO = "lightx2v/Qwen-Image-Edit-2511-Lightning"
-QWEN_LIGHTNING_WEIGHT = "Qwen-Image-Edit-2511-Lightning-4steps-V1.0-bf16.safetensors"
-QWEN_STEPS = 4
-QWEN_CFG = 1.0
-
-# 本家 krea/Krea-2-Turbo は gated (auto)。Space に HF_TOKEN シークレットを設定して
-# 利用規約に同意しておくか、非 gated のミラーを使う。
-KREA_REPO_CANDIDATES = [
-    os.environ.get("KREA_REPO"),
-    "krea/Krea-2-Turbo",
-    "unsloth/Krea-2-Turbo",
-    "CalamitousFelicitousness/Krea-2-Turbo-Diffusers",
-]
-KREA_STEPS = 8
-KREA_GUIDANCE = 0.0
-
-LOAD_NOTES: List[str] = []
-
-
-def _quantize(module) -> bool:
-    if not USE_FP8:
-        return False
-    try:
-        from torchao.quantization import Float8DynamicActivationFloat8WeightConfig, quantize_
-
-        quantize_(module, Float8DynamicActivationFloat8WeightConfig())
-        return True
-    except Exception as exc:  # noqa: BLE001
-        LOAD_NOTES.append(f"fp8 量子化に失敗 (bf16 で継続): {exc}")
-        return False
-
-
-def _load_qwen():
-    from diffusers import QwenImageEditPlusPipeline
-
-    pipe = QwenImageEditPlusPipeline.from_pretrained(QWEN_REPO, torch_dtype=DTYPE).to(DEVICE)
-    pipe.load_lora_weights(QWEN_LIGHTNING_REPO, weight_name=QWEN_LIGHTNING_WEIGHT)
-    pipe.fuse_lora(lora_scale=1.0)
-    pipe.unload_lora_weights()
-    _quantize(pipe.transformer)
-    return pipe
-
-
-def _load_krea():
-    try:
-        from diffusers import Krea2Pipeline
-    except ImportError as exc:
-        LOAD_NOTES.append(
-            "Krea2Pipeline を import できませんでした。diffusers 0.39.0 以上が必要です "
-            f"({exc})"
-        )
-        return None
-
-    last_error: Optional[Exception] = None
-    for repo in [r for r in KREA_REPO_CANDIDATES if r]:
-        try:
-            pipe = Krea2Pipeline.from_pretrained(repo, torch_dtype=DTYPE).to(DEVICE)
-            _quantize(pipe.transformer)
-            LOAD_NOTES.append(f"Krea 2 Turbo を `{repo}` から読み込み")
-            return pipe
-        except Exception as exc:  # noqa: BLE001
-            last_error = exc
-            LOAD_NOTES.append(f"`{repo}` の読み込みに失敗: {type(exc).__name__}")
-    LOAD_NOTES.append(
-        "Krea 2 Turbo を読み込めませんでした。本家 `krea/Krea-2-Turbo` は gated のため、"
-        "Space の Settings で HF_TOKEN シークレットを設定し、モデルページで利用規約に"
-        f"同意してください。最後のエラー: {last_error}"
-    )
-    return None
-
-
-qwen_pipe = _load_qwen() if MODELS in ("both", "qwen") else None
-krea_pipe = _load_krea() if MODELS in ("both", "krea") else None
-
-
-# --- 計測 -------------------------------------------------------------------
-
-
-def _measure(fn, runs: int) -> Dict:
-    """fn を runs 回実行し、時間とピーク VRAM を記録する。"""
-    torch.cuda.reset_peak_memory_stats()
-    timings: List[float] = []
-    image = None
-    for _ in range(runs):
-        torch.cuda.synchronize()
-        t0 = time.perf_counter()
-        image = fn()
-        torch.cuda.synchronize()
-        timings.append(time.perf_counter() - t0)
-    return {
-        "image": image,
-        "cold": timings[0],
-        "warm": statistics.median(timings[1:]) if len(timings) > 1 else timings[0],
-        "all": timings,
-        "peak_vram_gb": torch.cuda.max_memory_allocated() / (1024**3),
-    }
-
-
-def _bench_duration(reference, prompt, seed, width, height, runs, *args, **kwargs) -> int:
-    """要求 duration。Krea 8 step + Qwen 4 step を runs 回ずつ。"""
-    per_run = 12  # 1 枚あたりの余裕を見た秒数
-    models = sum(1 for p in (qwen_pipe, krea_pipe) if p is not None)
-    return int(30 + per_run * max(1, runs) * max(1, models))
-
-
-@spaces.GPU(duration=_bench_duration, size=GPU_SIZE)
-def run_benchmark(reference, prompt, seed, width, height, runs):
-    results: Dict[str, Dict] = {}
-
-    if qwen_pipe is not None:
-        if reference is None:
-            raise RuntimeError(
-                "Qwen-Image-Edit-2511 は編集モデルなので参照画像が必要です。"
-                "画像をアップロードするか BENCH_MODELS=krea にしてください。"
-            )
-        ref = reference.convert("RGB")
-
-        def _qwen():
-            gen = torch.Generator(device=DEVICE).manual_seed(int(seed))
-            return qwen_pipe(
-                image=[ref],
-                prompt=prompt,
-                negative_prompt=" ",
-                height=int(height),
-                width=int(width),
-                num_inference_steps=QWEN_STEPS,
-                generator=gen,
-                true_cfg_scale=QWEN_CFG,
-            ).images[0]
-
-        results["qwen"] = _measure(_qwen, int(runs))
-
-    if krea_pipe is not None:
-
-        def _krea():
-            gen = torch.Generator(device=DEVICE).manual_seed(int(seed))
-            return krea_pipe(
-                prompt,
-                height=int(height),
-                width=int(width),
-                num_inference_steps=KREA_STEPS,
-                guidance_scale=KREA_GUIDANCE,
-                generator=gen,
-            ).images[0]
-
-        results["krea"] = _measure(_krea, int(runs))
-
-    return results
-
-
-def _format_report(results: Dict[str, Dict], width: int, height: int, runs: int) -> str:
-    precision = "fp8 (torchao dynamic)" if USE_FP8 else "bf16"
-    lines = [
-        "## 実測結果",
-        "",
-        f"解像度 {width}×{height} / 各 {runs} 回 / 精度 {precision} / ZeroGPU size `{GPU_SIZE}`",
-        "",
-        "| モデル | モード | ステップ | cold (初回) | warm (中央値) | ピーク VRAM |",
-        "|---|---|:---:|---:|---:|---:|",
-    ]
-    labels = {
-        "qwen": ("Qwen-Image-Edit-2511 + Lightning", "画像編集 (i2i)", QWEN_STEPS),
-        "krea": ("Krea 2 Turbo", "text-to-image", KREA_STEPS),
-    }
-    for key, res in results.items():
-        name, mode, steps = labels[key]
-        lines.append(
-            f"| {name} | {mode} | {steps} | {res['cold']:.2f} 秒 | "
-            f"{res['warm']:.2f} 秒 | {res['peak_vram_gb']:.1f} GB |"
-        )
-
-    lines += [
-        "",
-        "### 読み方の注意",
-        "",
-        "- **同一ワークロードの比較ではない。** Krea 2 Turbo は stock diffusers では "
-        "text-to-image 専用で、参照画像から視点を派生させる編集ができない。"
-        "ここでは各モデルが本来の用途を実行したときのコストを並べている。",
-        "- ピーク VRAM は同一プロセス内の累積値なので、2 モデルを同時に読み込んだ場合は"
-        "分離できない。正確に測るには `BENCH_MODELS` で 1 モデルに絞ること。",
-        "- cold は初回呼び出し (カーネル選択や遅延初期化を含む)、warm は 2 回目以降の中央値。",
-    ]
-    if LOAD_NOTES:
-        lines += ["", "### 読み込み時のログ", ""] + [f"- {n}" for n in LOAD_NOTES]
-    return "\n".join(lines)
-
-
-def on_run(reference, prompt, seed, width, height, runs):
-    results = run_benchmark(reference, prompt, int(seed), int(width), int(height), int(runs))
-    gallery = []
-    if "qwen" in results:
-        gallery.append((results["qwen"]["image"], "Qwen-Image-Edit-2511 (i2i, 4 step)"))
-    if "krea" in results:
-        gallery.append((results["krea"]["image"], "Krea 2 Turbo (t2i, 8 step)"))
-    return gallery, _format_report(results, int(width), int(height), int(runs))
-
-
-# --- UI ---------------------------------------------------------------------
-
-with gr.Blocks() as demo:
-    gr.Markdown("# Krea 2 Turbo vs Qwen-Image-Edit-2511 ベンチマーク")
-    gr.Markdown(
-        "生成時間とピーク VRAM を実測して比較します。\n\n"
-        "⚠️ **同一ワークロードの比較ではありません。** Krea 2 Turbo は stock diffusers では "
-        "text-to-image 専用で、参照画像から多視点を派生させる編集機能がありません。"
-        "各モデルが本来の用途を実行したときのコストを並べたものです。\n\n"
-        f"現在の設定: モデル `{MODELS}` / fp8 `{USE_FP8}` / GPU size `{GPU_SIZE}`"
-    )
-    if LOAD_NOTES:
-        gr.Markdown("**読み込み時のログ**\n\n" + "\n".join(f"- {n}" for n in LOAD_NOTES))
-
-    with gr.Row():
-        with gr.Column():
-            reference = gr.Image(label="参照画像 (Qwen の編集用)", type="pil", height=320)
-            prompt = gr.Textbox(
-                label="プロンプト (両モデル共通)",
-                value="A full-body character standing in a neutral A-pose, plain white background.",
-                lines=3,
-            )
-            with gr.Row():
-                width = gr.Slider(label="幅", minimum=512, maximum=1536, step=64, value=1024)
-                height = gr.Slider(label="高さ", minimum=512, maximum=1536, step=64, value=1024)
-            with gr.Row():
-                seed = gr.Number(label="Seed", value=42, precision=0)
-                runs = gr.Slider(
-                    label="計測回数 (1回目は cold として別集計)",
-                    minimum=1, maximum=5, step=1, value=3,
-                )
-            run_button = gr.Button("⏱️ ベンチマーク実行", variant="primary")
-
-        with gr.Column():
-            gallery = gr.Gallery(label="出力", columns=2, height=420, object_fit="contain")
-            report = gr.Markdown()
-
-    run_button.click(
-        fn=on_run,
-        inputs=[reference, prompt, seed, width, height, runs],
-        outputs=[gallery, report],
-    )
-
-
-if __name__ == "__main__":
-    demo.launch()

bench/requirements.txt

@@ -1,20 +0,0 @@
-# Krea2Pipeline は diffusers 0.39.0 で追加された。それ未満だと import できない。
---extra-index-url https://download.pytorch.org/whl/cu130
-torch==2.11.0
-torchvision==0.26.0
-transformers==5.14.1
-accelerate==1.14.0
-diffusers==0.39.0
-peft==0.19.1
-huggingface-hub==1.24.0
-spaces==0.51.1
-torchao==0.16.0
-safetensors
-sentencepiece
-pillow
-
-# 注記: Krea 2 の identity 編集を比較したい場合は、非公式の diffusers 移植
-#   pip install git+https://github.com/huan-yin/Krea2-Identity-Edit-Diffusers
-# を追加する。ただし trust_remote_code が必要で、元になる LoRA
-# (conradlocke/krea2-identity-edit) はダウンロード実績がほぼ無く未検証。
-# Space のビルドを壊すおそれがあるため、既定では含めていない。

benchmark_local.py

@@ -0,0 +1,415 @@
+"""Calibrate the eleven-view Turbo workflow on a local CUDA GPU.
+
+No Spaces/Gradio import, quota timer, or captions are used. The angle LoRA is off
+by default and can be enabled for a comparison using an existing --image. An omitted
+--image uses the bundled mannequin for a speed smoke test only; --create-sample
+first generates a synthetic character reference with the same loaded model. A memory limit
+caps PyTorch's allocator; it does not emulate MIG, half a GPU, or ZeroGPU latency.
+"""
+import argparse
+from datetime import datetime, timezone
+import importlib.metadata
+import json
+import math
+from pathlib import Path
+import sys
+import time
+
+from PIL import Image
+
+from core import prepare_reference, conditioning_reference, rgb_on_white
+from pose_guides import get_guide
+from views import BY_KEY, DEFAULT_KEYS, SIZES, make_prompt, PROMPT_VERSION, REFERENCE_RESOLUTION
+
+# Keep in sync with backend.py without importing its ZeroGPU startup code.
+MODEL_ID = "Qwen/Qwen-Image-2.1-Turbo"
+MODEL_REVISION = "d65dbc9a7e8f6b5479e33dee6030eaab2a906509"
+ANGLES_REPO = "akhaliq/Qwen-Image-2.1-Multiple-Angles-LoRA"
+ANGLES_WEIGHT = ("checkpoints_v2/angles_v2_full_qwen21_multiple_angles_v2_"
+                 "qwen21_multiple_angles_v2_000001500.safetensors")
+ANGLES_STRENGTH = 0.8
+GIB = 1024**3
+SAMPLE_SEED = 20261012
+SAMPLE_PROMPT = (
+    "A single clean anime-style character illustration of a clearly adult woman in her late twenties, "
+    "full body, straight front view at eye level, standing in a relaxed neutral A-pose with her hands "
+    "lowered and legs narrowly spaced. Short teal bob haircut ending at her jaw, straight bangs, "
+    "amber eyes and a calm neutral expression. She wears a bright orange hip-length zip-front jacket "
+    "with a large cobalt-blue rectangular patch on the left chest and a yellow stripe around the "
+    "right forearm, a cream crew-neck shirt, straight dark navy trousers, and white ankle boots "
+    "with black soles. Opaque everyday clothing, natural adult proportions, clearly defined clothing "
+    "seams and consistent flat colors with restrained cel shading. Show the complete top of her "
+    "head and both boots with generous margins. Plain white background, soft even lighting. "
+    "One character only, no text, no letters, no logo, no reference panels, no collage."
+)
+
+
+def positive_int(value):
+    number = int(value)
+    if number < 1:
+        raise argparse.ArgumentTypeError("must be at least 1")
+    return number
+
+
+def positive_float(value):
+    number = float(value)
+    if not math.isfinite(number) or number <= 0:
+        raise argparse.ArgumentTypeError("must be a finite number greater than 0")
+    return number
+
+
+def parse_args(argv=None):
+    parser = argparse.ArgumentParser(description=__doc__)
+    source = parser.add_mutually_exclusive_group()
+    source.add_argument("--image", type=Path,
+                        help="Character reference. Omit both source options for mannequin-only speed smoke test.")
+    source.add_argument("--create-sample", action="store_true",
+                        help="Generate a synthetic adult anime character reference with the same loaded Turbo model.")
+    parser.add_argument("--output-dir", type=Path, required=True,
+                        help="Save PNGs and metrics.json here; existing metrics are never overwritten.")
+    parser.add_argument("--resolution", choices=tuple(SIZES), default="fast")
+    parser.add_argument("--pose-guides", choices=("on", "off"), default="on")
+    parser.add_argument("--reference-crop", choices=("on", "off"), default="off",
+                        help="Use close-view crops only for an upright full-body reference on white.")
+    parser.add_argument("--angles-lora", choices=("on", "off"), default="off",
+                        help="Compare the optional Qwen2.1 angle adapter at strength0.8. Requires --image.")
+    parser.add_argument("--repeat", type=positive_int, default=1,
+                        help="Number of complete eleven-view batches (default: 1).")
+    parser.add_argument("--warmup", type=int, choices=(0, 1), default=0,
+                        help="Optionally generate one extra front view before the measured batches. "
+                             "Its time, memory and image are also recorded (default: 0).")
+    parser.add_argument("--memory-limit-gib", type=positive_float,
+                        help="PyTorch allocator cap in GiB, e.g. 48. This is not a MIG/compute cap.")
+    parser.add_argument("--seed", type=int, default=0,
+                        help="Base seed; each view adds its fixed index, identical across repeats.")
+    args = parser.parse_args(argv)
+    if args.angles_lora == "on" and not args.image:
+        parser.error("--angles-lora on requires --image; reuse an existing reference "
+                     "instead of --create-sample for a comparable source image")
+    return args
+
+
+def write_metrics(path, metrics):
+    """Replace the JSON atomically, retaining completed results after a late error."""
+    temporary = path.with_suffix(".json.tmp")
+    temporary.write_text(json.dumps(metrics, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    temporary.replace(path)
+
+
+def cuda_memory(torch):
+    return {
+        "allocated_gib": round(torch.cuda.memory_allocated() / GIB, 4),
+        "reserved_gib": round(torch.cuda.memory_reserved() / GIB, 4),
+        "peak_allocated_gib": round(torch.cuda.max_memory_allocated() / GIB, 4),
+        "peak_reserved_gib": round(torch.cuda.max_memory_reserved() / GIB, 4),
+    }
+
+
+def package_versions():
+    versions = {}
+    for name in ("torch", "diffusers", "transformers", "accelerate", "peft", "pillow"):
+        try:
+            versions[name] = importlib.metadata.version(name)
+        except importlib.metadata.PackageNotFoundError:
+            versions[name] = None
+    return versions
+
+
+def benchmark(args):
+    output_dir = args.output_dir.expanduser().resolve()
+    output_dir.mkdir(parents=True, exist_ok=True)
+    metrics_path = output_dir / "metrics.json"
+    if metrics_path.exists():
+        raise FileExistsError(f"{metrics_path} already exists; choose a new --output-dir")
+
+    pose_enabled = args.pose_guides == "on"
+    angles_enabled = args.angles_lora == "on"
+    metrics = {
+        "status": "running",
+        "started_at_utc": datetime.now(timezone.utc).isoformat(),
+        "model": MODEL_ID,
+        "revision": MODEL_REVISION,
+        "input": str(args.image.expanduser().resolve()) if args.image else None,
+        "input_kind": ("user_reference" if args.image else
+                       "synthetic_character" if args.create_sample else "mannequin_speed_smoke_only"),
+        "quality_validation": "not performed by this benchmark",
+        "resolution": args.resolution,
+        "pose_guides": pose_enabled,
+        "angles_lora": angles_enabled,
+        "prompt_version": PROMPT_VERSION,
+        "conditioning": ("original reference with white-background close-view crops v1"
+                         if args.reference_crop == "on" else "original reference unchanged"),
+        "crop_close_views": args.reference_crop == "on",
+        "angles_adapter": ({"repo": ANGLES_REPO, "weight": ANGLES_WEIGHT,
+                            "strength": ANGLES_STRENGTH, "adapter_name": "angles",
+                            "strategy": "fuse on CPU, unload adapter, then move pipeline to CUDA"}
+                           if angles_enabled else None),
+        "base_seed": args.seed,
+        "requested_views": DEFAULT_KEYS,
+        "repeat": args.repeat,
+        "warmup": args.warmup,
+        "memory_limit_gib": args.memory_limit_gib,
+        "memory_limit_scope": "PyTorch allocator only; not MIG or a compute limit. "
+                              "Non-PyTorch CUDA allocations can be outside this cap.",
+        "timing_scope": "Each inference uses CUDA synchronization before and after the pipeline call; "
+                        "PNG writing is excluded. Batch wall time includes saving PNGs and metrics. "
+                        "Cold means the first pipeline call in this process. A synthetic reference "
+                        "or warmup prewarms the pipeline before the measured edit batches. "
+                        "No ZeroGPU startup, queue, transport, or quota is simulated.",
+        "pipeline": {"true_cfg_scale": 1.0, "use_kv_cache": True,
+                     "output_resolution": REFERENCE_RESOLUTION[args.resolution],
+                     "num_images_per_prompt": 1, "sampling": "checkpoint-configured eight sigmas"},
+        "packages": package_versions(),
+        "generations": [],
+        "batches": [],
+        "completed_images": 0,
+    }
+    write_metrics(metrics_path, metrics)
+    process_started = time.perf_counter()
+    torch = None
+    stage = "input_preparation"
+    active_generation = None
+    active_batch = None
+    pipeline_call_count = 0
+    edit_call_count = 0
+    exit_code = 0
+    try:
+        max_edge = 768 if args.resolution == "fast" else 1216
+        if args.image:
+            with Image.open(args.image.expanduser()) as source:
+                reference = prepare_reference(source, max_edge)
+        elif not args.create_sample:
+            reference = prepare_reference(get_guide("full_front", 512, 768), max_edge)
+            print("No --image: using the mannequin for a SPEED SMOKE TEST ONLY; "
+                  "these images do not validate character identity or pose quality.", flush=True)
+        else:
+            reference = None
+        if reference is not None:
+            metrics["reference_size"] = list(reference.size)
+        guides = None
+        if pose_enabled:
+            guides = {key: get_guide(key, *SIZES[args.resolution][BY_KEY[key].shape])
+                      for key in DEFAULT_KEYS}
+
+        stage = "cuda_initialization"
+        import torch as torch_module
+        torch = torch_module
+        if not torch.cuda.is_available():
+            raise RuntimeError("CUDA is unavailable; this benchmark requires a local CUDA GPU")
+        device = torch.cuda.current_device()
+        properties = torch.cuda.get_device_properties(device)
+        metrics["gpu"] = {"name": torch.cuda.get_device_name(device),
+                          "device_index": device,
+                          "total_memory_gib": round(properties.total_memory / GIB, 4),
+                          "compute_capability": f"{properties.major}.{properties.minor}",
+                          "torch_cuda_version": torch.version.cuda}
+        if args.memory_limit_gib is not None:
+            fraction = args.memory_limit_gib * GIB / properties.total_memory
+            if fraction > 1:
+                raise ValueError("--memory-limit-gib exceeds the selected GPU's total memory")
+            # Set before model loading or CUDA model placement.
+            torch.cuda.set_per_process_memory_fraction(fraction, device)
+            metrics["allocator_fraction"] = fraction
+            print(f"PyTorch allocator cap: {args.memory_limit_gib:g} GiB. "
+                  "The GPU still has its full compute capacity; this is not MIG or half-GPU emulation.",
+                  flush=True)
+        torch.cuda.synchronize()
+        torch.cuda.reset_peak_memory_stats()
+        write_metrics(metrics_path, metrics)
+
+        stage = "model_load"
+        from diffusers import QwenImage21Pipeline
+        load_started = time.perf_counter()
+        pipe = QwenImage21Pipeline.from_pretrained(
+            MODEL_ID, revision=MODEL_REVISION, dtype=torch.bfloat16,
+        )
+        pipe.set_progress_bar_config(disable=True)
+        if angles_enabled:
+            from huggingface_hub import hf_hub_download
+            from angles_adapter import load_angles_adapter
+            checkpoint = hf_hub_download(ANGLES_REPO, filename=ANGLES_WEIGHT)
+            metrics["angles_adapter"]["conversion"] = load_angles_adapter(
+                pipe, checkpoint, adapter_name="angles", strength=ANGLES_STRENGTH,
+            )
+            pipe.fuse_lora(adapter_names=["angles"])
+            pipe.unload_lora_weights()
+        pipe.vae.enable_tiling()
+        pipe.to("cuda")
+        torch.cuda.synchronize()
+        metrics["model_load_seconds"] = round(time.perf_counter() - load_started, 4)
+        metrics["model_load_scope"] = ("from_pretrained through CUDA placement; includes optional "
+                                       "CPU adapter fusion and downloads if uncached")
+        metrics["model_load_memory"] = cuda_memory(torch)
+        sample_sigmas = pipe.config.get("sample_sigmas", [])
+        if len(sample_sigmas) != 8:
+            raise RuntimeError("The pinned Turbo checkpoint's eight-sigma sampling schedule was not loaded")
+        metrics["sample_sigmas"] = list(sample_sigmas)
+        metrics["peak_allocated_gib"] = metrics["model_load_memory"]["peak_allocated_gib"]
+        metrics["peak_reserved_gib"] = metrics["model_load_memory"]["peak_reserved_gib"]
+        print(f"Loaded {metrics['gpu']['name']} in {metrics['model_load_seconds']:.3f}s; "
+              f"model allocation {metrics['model_load_memory']['allocated_gib']:.2f} GiB.", flush=True)
+        write_metrics(metrics_path, metrics)
+
+        if args.create_sample:
+            stage = "sample_generation"
+            active_generation = {
+                "phase": "sample_reference", "key": "reference", "status": "running",
+                "seed": SAMPLE_SEED, "prompt": SAMPLE_PROMPT,
+                "width": 832, "height": 1216, "output_resolution": 1024,
+                "references": 0, "cache_state": "cold", "is_first_pipeline_call": True,
+                "is_first_edit": False, "pipeline_call_index": 1,
+            }
+            metrics["sample_generation"] = active_generation
+            metrics["active_generation"] = active_generation
+            write_metrics(metrics_path, metrics)
+            torch.cuda.synchronize()
+            torch.cuda.reset_peak_memory_stats()
+            sample_started = time.perf_counter()
+            pipeline_call_count += 1
+            sample_image = pipe(
+                prompt=SAMPLE_PROMPT, width=832, height=1216, output_resolution=1024,
+                true_cfg_scale=1.0, use_kv_cache=True, num_images_per_prompt=1,
+                generator=torch.Generator("cpu").manual_seed(SAMPLE_SEED),
+            ).images[0]
+            torch.cuda.synchronize()
+            sample_seconds = round(time.perf_counter() - sample_started, 4)
+            active_generation["seconds"] = sample_seconds
+            active_generation.update(cuda_memory(torch))
+            stage = "sample_save"
+            rgb_on_white(sample_image).save(output_dir / "reference.png", format="PNG")
+            active_generation["image"] = "reference.png"
+            active_generation["status"] = "complete"
+            metrics["sample_generation_seconds"] = sample_seconds
+            metrics["cold_generation"] = dict(active_generation)
+            metrics["first_pipeline_generation"] = dict(active_generation)
+            for field in ("peak_allocated_gib", "peak_reserved_gib"):
+                metrics[field] = max(metrics[field], active_generation[field])
+            reference = prepare_reference(sample_image, max_edge)
+            metrics["reference_size"] = list(reference.size)
+            metrics["input"] = "reference.png"
+            metrics.pop("active_generation", None)
+            active_generation = None
+            write_metrics(metrics_path, metrics)
+            print(f"Synthetic reference: {sample_seconds:.3f}s; saved reference.png. "
+                  "This time is separate from edit batches; image quality has not been validated.", flush=True)
+
+        def generate(key, *, phase, repeat_index):
+            nonlocal stage, active_generation, pipeline_call_count, edit_call_count
+            view = BY_KEY[key]
+            width, height = SIZES[args.resolution][view.shape]
+            inputs = [conditioning_reference(reference, key, width, height)
+                      if args.reference_crop == "on" else reference]
+            if guides is not None:
+                inputs.append(guides[key])
+            seed = (args.seed + DEFAULT_KEYS.index(key)) % (2**31)
+            directory = output_dir / ("warmup" if phase == "warmup" else f"run_{repeat_index:02d}")
+            directory.mkdir(exist_ok=True)
+            target = directory / f"{DEFAULT_KEYS.index(key) + 1:02d}_{key}.png"
+            active_generation = {"key": key, "phase": phase, "repeat_index": repeat_index,
+                                 "cache_state": "cold" if pipeline_call_count == 0 else "warm",
+                                 "is_first_pipeline_call": pipeline_call_count == 0,
+                                 "is_first_edit": edit_call_count == 0,
+                                 "pipeline_call_index": pipeline_call_count + 1,
+                                 "seed": seed, "width": width, "height": height,
+                                 "references": len(inputs), "status": "running"}
+            metrics["active_generation"] = active_generation
+            write_metrics(metrics_path, metrics)
+            stage = "generation"
+            torch.cuda.synchronize()
+            torch.cuda.reset_peak_memory_stats()
+            inference_started = time.perf_counter()
+            pipeline_call_count += 1
+            edit_call_count += 1
+            # Match backend.py. No budget callback: calibration must attempt all eleven views.
+            edit_prompt = make_prompt(view, "", pose_enabled, angles_enabled)
+            active_generation["prompt"] = edit_prompt
+            image = pipe(
+                image=inputs, prompt=edit_prompt,
+                width=width, height=height,
+                output_resolution=REFERENCE_RESOLUTION[args.resolution],
+                true_cfg_scale=1.0, use_kv_cache=True, num_images_per_prompt=1,
+                generator=torch.Generator("cpu").manual_seed(seed),
+            ).images[0]
+            torch.cuda.synchronize()
+            active_generation["seconds"] = round(time.perf_counter() - inference_started, 4)
+            active_generation.update(cuda_memory(torch))
+            stage = "image_save"
+            rgb_on_white(image).save(target, format="PNG")
+            active_generation["image"] = str(target.relative_to(output_dir))
+            active_generation["status"] = "complete"
+            metrics["generations"].append(active_generation)
+            if active_generation["cache_state"] == "cold":
+                metrics["cold_generation"] = dict(active_generation)
+            if active_generation["is_first_pipeline_call"]:
+                metrics["first_pipeline_generation"] = dict(active_generation)
+            if active_generation["is_first_edit"]:
+                metrics["first_edit_generation"] = dict(active_generation)
+            for field in ("peak_allocated_gib", "peak_reserved_gib"):
+                metrics[field] = max(metrics[field], active_generation[field])
+            metrics["completed_images"] += 1
+            if phase == "batch":
+                active_batch["completed_views"].append(key)
+                active_batch["inference_seconds"] = round(
+                    active_batch["inference_seconds"] + active_generation["seconds"], 4)
+            metrics.pop("active_generation", None)
+            completed = active_generation
+            active_generation = None
+            write_metrics(metrics_path, metrics)
+            print(f"{phase} {repeat_index or '-'} / {key}: {completed['seconds']:.3f}s, "
+                  f"peak allocated {completed['peak_allocated_gib']:.2f} GiB, "
+                  f"peak reserved {completed['peak_reserved_gib']:.2f} GiB "
+                  f"({completed['cache_state']})", flush=True)
+
+        if args.warmup:
+            generate("full_front", phase="warmup", repeat_index=0)
+        for repeat_index in range(1, args.repeat + 1):
+            active_batch = {"repeat_index": repeat_index, "status": "running",
+                            "completed_views": [], "inference_seconds": 0.0,
+                            "includes_cold_generation": pipeline_call_count == 0}
+            metrics["batches"].append(active_batch)
+            batch_started = time.perf_counter()
+            for key in DEFAULT_KEYS:
+                generate(key, phase="batch", repeat_index=repeat_index)
+            active_batch["wall_seconds"] = round(time.perf_counter() - batch_started, 4)
+            active_batch["status"] = "complete"
+            print(f"Batch {repeat_index}: 11/11 views, inference "
+                  f"{active_batch['inference_seconds']:.3f}s, wall {active_batch['wall_seconds']:.3f}s.",
+                  flush=True)
+            write_metrics(metrics_path, metrics)
+            active_batch = None
+        metrics["status"] = "complete"
+    except (Exception, KeyboardInterrupt) as exc:
+        exit_code = 130 if isinstance(exc, KeyboardInterrupt) else 1
+        metrics["status"] = "interrupted" if exit_code == 130 else "failed"
+        metrics["error"] = {"stage": stage, "type": type(exc).__name__, "message": str(exc)}
+        if active_generation is not None:
+            active_generation["status"] = metrics["status"]
+        if active_batch is not None:
+            active_batch["status"] = metrics["status"]
+            active_batch["wall_seconds"] = round(time.perf_counter() - batch_started, 4)
+        if torch is not None:
+            try:
+                metrics["memory_at_failure"] = cuda_memory(torch)
+            except Exception:
+                pass
+        print(f"Benchmark {metrics['status']} during {stage}: {type(exc).__name__}: {exc}\n"
+              "Completed PNGs and metrics are retained.", file=sys.stderr, flush=True)
+    finally:
+        metrics["process_seconds"] = round(time.perf_counter() - process_started, 4)
+        metrics["finished_at_utc"] = datetime.now(timezone.utc).isoformat()
+        write_metrics(metrics_path, metrics)
+        print(f"Metrics: {metrics_path}", flush=True)
+    return exit_code
+
+
+def main(argv=None):
+    args = parse_args(argv)
+    try:
+        return benchmark(args)
+    except (OSError, ValueError) as exc:
+        print(f"Cannot start benchmark: {exc}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

core.py

@@ -0,0 +1,151 @@
+"""CPU-side dataset export and time-budget orchestration; independently testable."""
+import io
+import tempfile
+import time
+import zipfile
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from PIL import Image, ImageChops, ImageOps
+
+from views import BY_KEY, DEFAULT_KEYS, SIZES, make_prompt, validate_keys
+
+
+class BudgetExhausted(Exception):
+    pass
+
+
+@dataclass
+class BatchResult:
+    images: dict = field(default_factory=dict)
+    timings: list = field(default_factory=list)
+    stop_reason: str = ""
+
+
+def rgb_on_white(image):
+    """Return an independent RGB image, compositing any transparency onto white."""
+    rgba = image.convert("RGBA")
+    white = Image.new("RGBA", rgba.size, "white")
+    white.alpha_composite(rgba)
+    return white.convert("RGB")
+
+
+def prepare_reference(image, max_edge):
+    image = ImageOps.exif_transpose(image)
+    result = rgb_on_white(image)
+    result.thumbnail((max_edge, max_edge), Image.Resampling.LANCZOS)
+    return result
+
+
+def conditioning_reference(reference, key, width, height):
+    """Crop close views from an upright full-body reference on a white background.
+
+    Fractions are measured from the detected foreground's head to feet. Crops are
+    derived independently from the original reference, with a small head margin,
+    and fitted proportionally onto a white canvas at the requested output size.
+    Full-body/pose views preserve the original reference object unchanged.
+    """
+    fraction = {"cowboy_front": 0.72, "cowboy_back": 0.72,
+                "upper_front": 0.45, "face_front": 0.20}.get(key)
+    if fraction is None:
+        return reference
+    if width <= 0 or height <= 0:
+        raise ValueError("Conditioning dimensions must be positive")
+    rgb = rgb_on_white(reference)
+    difference = ImageChops.difference(rgb, Image.new("RGB", rgb.size, "white"))
+    red, green, blue = difference.split()
+    distance = ImageChops.lighter(ImageChops.lighter(red, green), blue)
+    mask = distance.point(lambda value: 255 if value > 18 else 0)
+    bbox = mask.getbbox() or (0, 0, rgb.width, rgb.height)
+    subject_height = bbox[3] - bbox[1]
+    keep_height = max(1, round(subject_height * fraction))
+    top_padding = max(1, round(keep_height * 0.06))
+    top = max(0, bbox[1] - top_padding)
+    bottom = min(rgb.height, bbox[1] + keep_height)
+
+    # Use this band's foreground width so the full body's arms/legs do not force
+    # excess whitespace around a face crop. Preserve a small horizontal margin.
+    band_bbox = mask.crop((0, top, rgb.width, bottom)).getbbox()
+    left, right = (band_bbox[0], band_bbox[2]) if band_bbox else (bbox[0], bbox[2])
+    side_padding = max(1, round((right - left) * 0.06))
+    crop = rgb.crop((max(0, left - side_padding), top,
+                    min(rgb.width, right + side_padding), bottom))
+    fitted = ImageOps.contain(crop, (width, height), Image.Resampling.LANCZOS)
+    canvas = Image.new("RGB", (width, height), "white")
+    canvas.paste(fitted, ((width - fitted.width) // 2, (height - fitted.height) // 2))
+    return canvas
+
+
+def requested_seconds(keys, maximum=110):
+    """An execution budget, NOT a benchmark-based estimate or a guarantee."""
+    # Even a one-view smoke test needs startup and decode time in addition to
+    # the denoising budget. Keep a practical floor without claiming a speed.
+    return min(maximum, max(45, 15 + 10 * len(validate_keys(keys))))
+
+
+def run_batch(generate_one, reference, keys, guide_images, resolution, seed, extra,
+              angles, budget_seconds, clock=time.monotonic, crop_close_views=False):
+    keys = validate_keys(keys)
+    result = BatchResult()
+    started = clock()
+    deadline = started + budget_seconds
+    longest = 0.0
+
+    def check_budget():
+        # Called at denoising step boundaries. Leave room for decode and result transfer.
+        if clock() >= deadline - 6:
+            raise BudgetExhausted()
+
+    for key in keys:
+        remaining = deadline - clock()
+        if remaining <= max(8.0, longest * 1.4 + 6):
+            result.stop_reason = "時間枠に達する前に終了しました。完成した画像を保存できます。"
+            break
+        view = BY_KEY[key]
+        width, height = SIZES[resolution][view.shape]
+        inputs = [conditioning_reference(reference, key, width, height)
+                  if crop_close_views else reference]
+        if guide_images is not None:
+            inputs.append(guide_images[key])
+        # Stable per-view seed, unaffected by selecting or reordering other views.
+        view_seed = (int(seed) + DEFAULT_KEYS.index(key)) % (2**31)
+        t0 = clock()
+        try:
+            output = generate_one(
+                image=inputs, prompt=make_prompt(view, extra, guide_images is not None, angles),
+                width=width, height=height, seed=view_seed, check_budget=check_budget,
+            )
+        except BudgetExhausted:
+            result.stop_reason = "時間枠に達する前に終了しました。完成した画像を保存できます。"
+            break
+        except Exception as exc:
+            # A late view failure must not discard images already completed.
+            print(f"[generation] {key} failed: {type(exc).__name__}: {exc}", flush=True)
+            result.stop_reason = f"「{view.label}」の生成に失敗しました。完成済み画像は保存できます。"
+            break
+        elapsed = clock() - t0
+        longest = max(longest, elapsed)
+        result.images[key] = output
+        result.timings.append({"key": key, "seconds": round(elapsed, 3), "seed": view_seed,
+                               "width": width, "height": height, "references": len(inputs)})
+        print(f"[generation] {key}: {elapsed:.2f}s", flush=True)
+    return result
+
+
+def build_zip(images, selected_keys, output_dir=None):
+    """Export PNGs only; optionally write inside a caller-managed directory."""
+    keys = validate_keys(selected_keys)
+    if not any(key in images for key in keys):
+        return None
+    folder = Path(output_dir) if output_dir is not None else Path(tempfile.mkdtemp(prefix="character-views-"))
+    folder.mkdir(parents=True, exist_ok=True)
+    target = folder / "character_views.zip"
+    with zipfile.ZipFile(target, "w", zipfile.ZIP_STORED) as archive:
+        for key in keys:
+            if key not in images:
+                continue
+            buffer = io.BytesIO()
+            rgb_on_white(images[key]).save(buffer, format="PNG")
+            index = DEFAULT_KEYS.index(key) + 1
+            archive.writestr(f"dataset/{index:02d}_{key}.png", buffer.getvalue())
+    return str(target)

framing.py

@@ -1,59 +0,0 @@
-"""寄り視点用に、全身画像から目的の構図を切り出すユーティリティ.
-
-なぜ必要か (実機検証の結果):
-  全身画像を条件にして「カウボーイショットにして」とプロンプトで頼んでも、
-  Qwen-Image-Edit は入力のフレーミングを保とうとして全身のまま出力する。
-  プロンプトの言い回しを 8 通り試しても直らなかった。
-  あらかじめ目的の構図に切り出した画像を条件にすると、フレーミングが
-  決定的に決まり、モデルはディテール補完に専念できる。
-"""
-
-from typing import Tuple
-
-import numpy as np
-from PIL import Image
-
-#: 被写体の全高を 1.0 としたときに、頭頂から何割を残すか
-CROP_FRACTION = {
-    "face": 0.20,
-    "upper": 0.45,
-    "cowboy": 0.72,
-}
-
-#: 顔が切れないように上へ足す余白 (切り出し高さに対する割合)
-TOP_PAD_RATIO = 0.06
-
-
-def subject_bbox(img: Image.Image, tol: int = 18) -> Tuple[int, int, int, int]:
-    """白背景を除いた被写体のバウンディングボックス (x0, y0, x1, y1)。
-
-    背景は全視点で plain white に固定しているので、白からの距離で判定できる。
-    被写体が見つからない場合は画像全体を返す。
-    """
-    arr = np.asarray(img.convert("RGB")).astype(np.int16)
-    mask = (255 - arr).max(axis=2) > tol
-    ys, xs = np.nonzero(mask)
-    if len(ys) == 0:
-        return (0, 0, img.width, img.height)
-    return (int(xs.min()), int(ys.min()), int(xs.max()) + 1, int(ys.max()) + 1)
-
-
-def crop_framing(img: Image.Image, kind: str, out_w: int, out_h: int) -> Image.Image:
-    """被写体の上から一定割合を切り出し、出力アスペクト比に合わせて整える。"""
-    if kind not in CROP_FRACTION:
-        return img
-
-    x0, y0, x1, y1 = subject_bbox(img)
-    subject_h = max(1, y1 - y0)
-    keep_h = max(8, int(subject_h * CROP_FRACTION[kind]))
-
-    cy0 = max(0, y0 - int(keep_h * TOP_PAD_RATIO))
-    cy1 = min(img.height, cy0 + keep_h)
-
-    # 出力アスペクト比に合わせて横幅を決め、被写体の水平中心に寄せる
-    need_w = max(8, int((cy1 - cy0) * (out_w / out_h)))
-    cx = (x0 + x1) // 2
-    cx0 = max(0, min(cx - need_w // 2, img.width - need_w)) if need_w <= img.width else 0
-    cx1 = min(img.width, cx0 + need_w)
-
-    return img.crop((cx0, cy0, cx1, cy1)).resize((out_w, out_h), Image.LANCZOS)

optimization.py

@@ -1,167 +0,0 @@
-"""ZeroGPU 向け高速化 (fp8 量子化 + PyTorch ahead-of-time コンパイル).
-
-tori29umai/Qwen-Image-2509-CharacterSheet の optimization.py を土台に、
-fp8 量子化を有効化し、失敗時に素の bf16 へフォールバックする経路を足したもの。
-
-なぜ必要か:
-  ZeroGPU は 2026/05 に H200 (~70GB) から RTX Pro 6000 Blackwell へ移行し、
-  既定の `large` サイズは 48GB になった。Qwen-Image-Edit-2511 は bf16 で
-  transformer 40.9GB + text encoder 16.6GB ≈ 57GB あり、48GB 枠に収まらない。
-  fp8 量子化で transformer を約半分に落とすことが実質的な前提条件になる。
-
-  さらに ZeroGPU はクォータを「実行時間」ではなく「要求 duration」で消費するため、
-  1 視点あたりの生成時間を削ることがそのまま無料枠での生成可能枚数に効く。
-
-環境変数:
-  DISABLE_FP8=1   fp8 量子化を無効化 (bf16 のまま)
-  DISABLE_AOTI=1  AoTI コンパイルを無効化
-  DISABLE_FA3=1   FlashAttention-3 を無効化
-"""
-
-import os
-from typing import Any, Callable, ParamSpec
-
-import spaces
-import torch
-from torch.utils._pytree import tree_map
-
-P = ParamSpec("P")
-
-
-TRANSFORMER_IMAGE_SEQ_LENGTH_DIM = torch.export.Dim("image_seq_length")
-TRANSFORMER_TEXT_SEQ_LENGTH_DIM = torch.export.Dim("text_seq_length")
-
-# 画像/テキストの系列長を動的次元にしておくことで、視点ごとに解像度が変わっても
-# (832x1216 / 1024x1024 / 1216x832) 再コンパイルが走らない。
-TRANSFORMER_DYNAMIC_SHAPES = {
-    "hidden_states": {
-        1: TRANSFORMER_IMAGE_SEQ_LENGTH_DIM,
-    },
-    "encoder_hidden_states": {
-        1: TRANSFORMER_TEXT_SEQ_LENGTH_DIM,
-    },
-    "encoder_hidden_states_mask": {
-        1: TRANSFORMER_TEXT_SEQ_LENGTH_DIM,
-    },
-    "image_rotary_emb": (
-        {0: TRANSFORMER_IMAGE_SEQ_LENGTH_DIM},
-        {0: TRANSFORMER_TEXT_SEQ_LENGTH_DIM},
-    ),
-}
-
-
-INDUCTOR_CONFIGS = {
-    "conv_1x1_as_mm": True,
-    "epilogue_fusion": False,
-    "coordinate_descent_tuning": True,
-    "coordinate_descent_check_all_directions": True,
-    "max_autotune": True,
-    "triton.cudagraphs": True,
-}
-
-
-def _env_off(name: str) -> bool:
-    return os.environ.get(name, "").strip() not in ("", "0", "false", "False")
-
-
-def apply_fa3_(pipeline) -> bool:
-    """FlashAttention-3 の attention processor を適用する。成功したら True。"""
-    if _env_off("DISABLE_FA3"):
-        print("[optimization] FA3 は DISABLE_FA3 により無効")
-        return False
-    try:
-        from qwenimage.qwen_fa3_processor import QwenDoubleStreamAttnProcessorFA3
-
-        pipeline.transformer.set_attn_processor(QwenDoubleStreamAttnProcessorFA3())
-        print("[optimization] FlashAttention-3 を適用")
-        return True
-    except Exception as exc:  # noqa: BLE001 - Space を落とさないことを優先
-        print(f"[optimization] FA3 を適用できず既定の attention を使用: {exc}")
-        return False
-
-
-#: 量子化は一度きり。AoTI が途中で失敗した場合にフォールバック側が二重適用しないよう記録する。
-_FP8_APPLIED = False
-
-
-def quantize_fp8_(module) -> bool:
-    """transformer を fp8 動的量子化する。成功したら True。
-
-    VRAM を約半減させるのが主目的で、副次的に ~1.2x の高速化が乗る。
-    """
-    global _FP8_APPLIED
-    if _FP8_APPLIED:
-        return True
-    if _env_off("DISABLE_FP8"):
-        print("[optimization] fp8 は DISABLE_FP8 により無効")
-        return False
-    try:
-        from torchao.quantization import (
-            Float8DynamicActivationFloat8WeightConfig,
-            quantize_,
-        )
-
-        quantize_(module, Float8DynamicActivationFloat8WeightConfig())
-        _FP8_APPLIED = True
-        print("[optimization] fp8 動的量子化を適用")
-        return True
-    except Exception as exc:  # noqa: BLE001
-        print(f"[optimization] fp8 量子化に失敗、bf16 のまま継続: {exc}")
-        return False
-
-
-def optimize_pipeline_(pipeline: Callable[P, Any], *args: P.args, **kwargs: P.kwargs) -> bool:
-    """fp8 量子化 + AoTI コンパイルを適用する。AoTI まで通ったら True。
-
-    量子化と export は同一の GPU コンテキスト内で行う必要があるため、
-    まとめて `@spaces.GPU` 関数の中で実行する。
-    """
-    if _env_off("DISABLE_AOTI"):
-        print("[optimization] AoTI は DISABLE_AOTI により無効")
-        if not _FP8_APPLIED:
-            # 通常は app.py 側が CPU 上で量子化済み。未適用ならここで救済する。
-            @spaces.GPU(duration=120)
-            def quantize_only():
-                return quantize_fp8_(pipeline.transformer)
-
-            quantize_only()
-        return False
-
-    @spaces.GPU(duration=1500)
-    def compile_transformer():
-        # 実入力の形状を捕まえるためにパイプラインを 1 回だけ空回しする
-        with spaces.aoti_capture(pipeline.transformer) as call:
-            pipeline(*args, **kwargs)
-
-        dynamic_shapes = tree_map(lambda t: None, call.kwargs)
-        dynamic_shapes |= TRANSFORMER_DYNAMIC_SHAPES
-
-        # 通常は app.py 側で CPU 転送前に量子化済み (_FP8_APPLIED が True なので no-op)。
-        # export より前に済んでいれば、量子化後のカーネルがグラフに焼き込まれる。
-        quantize_fp8_(pipeline.transformer)
-
-        exported = torch.export.export(
-            mod=pipeline.transformer,
-            args=call.args,
-            kwargs=call.kwargs,
-            dynamic_shapes=dynamic_shapes,
-        )
-        return spaces.aoti_compile(exported, INDUCTOR_CONFIGS)
-
-    try:
-        spaces.aoti_apply(compile_transformer(), pipeline.transformer)
-        print("[optimization] AoTI コンパイル済みの transformer を適用")
-        return True
-    except Exception as exc:  # noqa: BLE001
-        # コンパイルに失敗しても Space は動き続けるべき。量子化だけでも効果はある。
-        print(f"[optimization] AoTI コンパイルに失敗、非コンパイル経路で継続: {exc}")
-
-        @spaces.GPU(duration=120)
-        def quantize_fallback():
-            return quantize_fp8_(pipeline.transformer)
-
-        try:
-            quantize_fallback()
-        except Exception as exc2:  # noqa: BLE001
-            print(f"[optimization] fp8 フォールバックも失敗: {exc2}")
-        return False

pose_guides.py

@@ -0,0 +1,330 @@
+"""Deterministic, neutral pose mannequins for the eleven reference views.
+
+These are ordinary RGB image references, not ControlNet or OpenPose maps. They
+describe pose/camera/framing; a separate character image supplies identity.
+No network, downloaded models, random sampling, or GPU is used. Pillow is the
+only third-party dependency. Run ``python pose_guides.py --regenerate`` to
+rebuild the bundled assets.
+"""
+
+from __future__ import annotations
+
+import math
+from pathlib import Path
+
+from PIL import Image, ImageDraw, ImageFont
+
+
+ASSET_DIR = Path(__file__).resolve().parent / "assets"
+GUIDE_VERSION = 1
+# key: (English preview label, pose, camera azimuth, elevation, crop, size)
+GUIDE_SPECS = {
+    "full_front": ("01  Full / front", "standing", 0, 0, "full", (832, 1216)),
+    "full_left": ("02  Full / left", "standing", 270, 0, "full", (832, 1216)),
+    "full_right": ("03  Full / right", "standing", 90, 0, "full", (832, 1216)),
+    "full_back": ("04  Full / back", "standing", 180, 0, "full", (832, 1216)),
+    "cowboy_front": ("05  Mid-thigh / front", "standing", 0, 0, "cowboy", (1024, 1024)),
+    "cowboy_back": ("06  Mid-thigh / back", "standing", 180, 0, "cowboy", (1024, 1024)),
+    "upper_front": ("07  Upper body / front", "standing", 0, 0, "upper", (1024, 1024)),
+    "face_front": ("08  Face / front", "standing", 0, 0, "face", (1024, 1024)),
+    "knees_front": ("09  Hug knees / front", "knees", 0, 0, "full", (832, 1216)),
+    "knees_back": ("10  Hug knees / back", "knees", 180, 0, "full", (832, 1216)),
+    "prone_back": ("11  Prone / rear, elevated", "prone", 180, 60, "full", (1216, 832)),
+}
+
+
+def _add(a, b):
+    return tuple(x + y for x, y in zip(a, b))
+
+
+def _sub(a, b):
+    return tuple(x - y for x, y in zip(a, b))
+
+
+def _mul(a, scale):
+    return tuple(x * scale for x in a)
+
+
+def _dot(a, b):
+    return sum(x * y for x, y in zip(a, b))
+
+
+def _cross(a, b):
+    return (a[1] * b[2] - a[2] * b[1],
+            a[2] * b[0] - a[0] * b[2],
+            a[0] * b[1] - a[1] * b[0])
+
+
+def _unit(a):
+    length = math.sqrt(_dot(a, a))
+    return _mul(a, 1 / length) if length > 1e-12 else (0.0, 1.0, 0.0)
+
+
+class _Mannequin:
+    """Small ellipsoid mesh model with articulated limbs and subtle joints."""
+
+    def __init__(self):
+        self.faces = []
+
+    def ellipsoid(self, center, radii, tone=177, axis=(0, 1, 0), facing=None):
+        ey = _unit(axis)
+        if facing is None:
+            helper = (0, 0, 1) if abs(ey[2]) < 0.9 else (0, 1, 0)
+            ex = _unit(_cross(ey, helper))
+            ez = _unit(_cross(ex, ey))
+        else:
+            ez = _unit(facing)
+            ex = _unit(_cross(ey, ez))
+            ez = _unit(_cross(ex, ey))
+        rings, sectors = 40, 72
+        vertices = []
+        for ring in range(rings + 1):
+            latitude = math.pi * ring / rings
+            row = []
+            for sector in range(sectors):
+                longitude = 2 * math.pi * sector / sectors
+                local = (radii[0] * math.sin(latitude) * math.cos(longitude),
+                         radii[1] * math.cos(latitude),
+                         radii[2] * math.sin(latitude) * math.sin(longitude))
+                world = _add(center, _add(_mul(ex, local[0]),
+                                         _add(_mul(ey, local[1]), _mul(ez, local[2]))))
+                normal = _unit(_add(_mul(ex, local[0] / radii[0] ** 2),
+                                    _add(_mul(ey, local[1] / radii[1] ** 2),
+                                         _mul(ez, local[2] / radii[2] ** 2))))
+                row.append((world, normal))
+            vertices.append(row)
+        for ring in range(rings):
+            for sector in range(sectors):
+                next_sector = (sector + 1) % sectors
+                corners = [vertices[ring][sector], vertices[ring + 1][sector],
+                           vertices[ring + 1][next_sector], vertices[ring][next_sector]]
+                points = tuple(v[0] for v in corners)
+                normal = _unit(tuple(sum(v[1][i] for v in corners) for i in range(3)))
+                self.faces.append((points, normal, tone))
+
+    def limb(self, start, end, radius, tone=178):
+        delta = _sub(end, start)
+        length = math.sqrt(_dot(delta, delta))
+        self.ellipsoid(_mul(_add(start, end), 0.5),
+                       (radius, length / 2 + radius * 0.5, radius), tone, delta)
+
+    def joint(self, point, radius):
+        self.ellipsoid(point, (radius, radius, radius), 160)
+
+    def head(self, center, axis=(0, 1, 0), facing=(0, 0, 1)):
+        up, forward = _unit(axis), _unit(facing)
+        side = _unit(_cross(up, forward))
+        self.ellipsoid(center, (0.105, 0.145, 0.101), 187, up, forward)
+        # A short, blunt nose and small ears make front/back/side unambiguous.
+        nose = _add(center, _add(_mul(forward, 0.105), _mul(up, -0.01)))
+        self.ellipsoid(nose, (0.018, 0.029, 0.033), 179, up, forward)
+        for sign in (-1, 1):
+            ear = _add(center, _add(_mul(side, sign * 0.103), _mul(up, -0.005)))
+            self.ellipsoid(ear, (0.019, 0.032, 0.019), 176, up, forward)
+
+
+def _standing():
+    model = _Mannequin()
+    model.ellipsoid((0, 1.26, 0), (0.189, 0.237, 0.103))
+    model.ellipsoid((0, 1.045, 0), (0.130, 0.129, 0.091), 172)
+    model.ellipsoid((0, 0.958, -0.002), (0.158, 0.125, 0.108), 180)
+    model.limb((0, 1.438, 0), (0, 1.536, 0), 0.052)
+    model.head((0, 1.665, 0))
+    for side in (-1, 1):
+        shoulder = (side * 0.196, 1.398, 0)
+        elbow = (side * 0.264, 1.130, 0)
+        wrist = (side * 0.309, 0.901, 0.016)
+        model.joint(shoulder, 0.071)
+        model.limb(shoulder, elbow, 0.063)
+        model.joint(elbow, 0.046)
+        model.limb(elbow, wrist, 0.047)
+        model.joint(wrist, 0.030)
+        model.ellipsoid((side * 0.319, 0.846, 0.02), (0.039, 0.069, 0.025), 183,
+                        (side * 0.13, 1, 0))
+        hip = (side * 0.089, 0.920, 0)
+        knee = (side * 0.105, 0.516, 0.010)
+        ankle = (side * 0.111, 0.097, 0)
+        model.limb(hip, knee, 0.085)
+        model.joint(knee, 0.057)
+        model.limb(knee, ankle, 0.057)
+        model.joint(ankle, 0.039)
+        model.ellipsoid((side * 0.111, 0.049, 0.068), (0.059, 0.048, 0.125), 180)
+    return model
+
+
+def _knees():
+    model = _Mannequin()
+    model.ellipsoid((0, 0.230, -0.111), (0.163, 0.135, 0.119), 180)
+    model.ellipsoid((0, 0.445, -0.148), (0.151, 0.190, 0.103), 173,
+                    (0, 1, 0.10))
+    model.ellipsoid((0, 0.624, -0.096), (0.183, 0.177, 0.099), 177,
+                    (0, 1, 0.24))
+    model.limb((0, 0.745, -0.065), (0, 0.823, -0.01), 0.050)
+    model.head((0, 0.939, 0.024), axis=(0, 0.99, 0.08), facing=(0, -0.08, 0.99))
+    for side in (-1, 1):
+        hip = (side * 0.105, 0.226, -0.080)
+        knee = (side * 0.116, 0.603, 0.248)
+        ankle = (side * 0.119, 0.097, 0.320)
+        model.limb(hip, knee, 0.086)
+        model.joint(knee, 0.062)
+        model.limb(knee, ankle, 0.056)
+        model.joint(ankle, 0.038)
+        model.ellipsoid((side * 0.120, 0.050, 0.383), (0.061, 0.050, 0.114), 180)
+        shoulder = (side * 0.186, 0.724, -0.064)
+        elbow = (side * 0.264, 0.465, 0.257)
+        wrist = (side * 0.085, 0.470, 0.356)
+        model.joint(shoulder, 0.063)
+        model.limb(shoulder, elbow, 0.058)
+        model.joint(elbow, 0.043)
+        model.limb(elbow, wrist, 0.043)
+        model.joint(wrist, 0.027)
+        model.ellipsoid((side * 0.037, 0.467 + side * 0.012, 0.359),
+                        (0.030, 0.062, 0.023), 184, (1, side * 0.1, 0))
+    return model
+
+
+def _prone():
+    model = _Mannequin()
+    model.ellipsoid((0, 0.178, 1.227), (0.189, 0.237, 0.103), axis=(0, 0, 1), facing=(0, -1, 0))
+    model.ellipsoid((0, 0.165, 1.021), (0.130, 0.130, 0.092), 172,
+                    axis=(0, 0, 1), facing=(0, -1, 0))
+    model.ellipsoid((0, 0.182, 0.924), (0.158, 0.127, 0.111), 180,
+                    axis=(0, 0, 1), facing=(0, -1, 0))
+    model.limb((0, 0.17, 1.418), (0, 0.16, 1.500), 0.052)
+    model.head((0, 0.162, 1.641), axis=(0, 0, 1), facing=(0, -1, 0))
+    for side in (-1, 1):
+        shoulder = (side * 0.195, 0.172, 1.372)
+        elbow = (side * 0.375, 0.083, 1.606)
+        wrist = (side * 0.244, 0.065, 1.797)
+        model.joint(shoulder, 0.068)
+        model.limb(shoulder, elbow, 0.060)
+        model.joint(elbow, 0.043)
+        model.limb(elbow, wrist, 0.045)
+        model.joint(wrist, 0.027)
+        model.ellipsoid((side * 0.188, 0.052, 1.823), (0.032, 0.066, 0.023), 183,
+                        axis=(side, 0, -0.2), facing=(0, -1, 0))
+        hip = (side * 0.090, 0.177, 0.899)
+        knee = (side * 0.105, 0.116, 0.491)
+        ankle = (side * 0.113, 0.083, 0.098)
+        model.limb(hip, knee, 0.083)
+        model.joint(knee, 0.055)
+        model.limb(knee, ankle, 0.056)
+        model.joint(ankle, 0.036)
+        model.ellipsoid((side * 0.114, 0.058, 0.026), (0.058, 0.111, 0.047), 180,
+                        axis=(0, -0.25, 1), facing=(0, -1, -0.25))
+    return model
+
+
+def _render(model, azimuth, elevation, crop, size, pose):
+    azimuth, elevation = math.radians(azimuth), math.radians(elevation)
+    toward = (math.sin(azimuth) * math.cos(elevation), math.sin(elevation),
+              math.cos(azimuth) * math.cos(elevation))
+    right = (math.cos(azimuth), 0, -math.sin(azimuth))
+    up = _cross(toward, right)
+    if pose == "prone":
+        # Roll the overhead camera so the long body fits the landscape bucket.
+        right, up = up, _mul(right, -1)
+    projected = [(_dot(vertex, right), _dot(vertex, up))
+                 for points, _, _ in model.faces for vertex in points]
+    min_x, max_x = min(v[0] for v in projected), max(v[0] for v in projected)
+    min_y, max_y = min(v[1] for v in projected), max(v[1] for v in projected)
+    if crop != "full":
+        # Absolute anatomical cut planes avoid uncertain image segmentation.
+        min_y = {"cowboy": 0.705, "upper": 1.160, "face": 1.493}[crop]
+        max_y += {"cowboy": 0.065, "upper": 0.047, "face": 0.025}[crop]
+    else:
+        height = max_y - min_y
+        min_y -= height * 0.055
+        max_y += height * 0.065
+        width = max_x - min_x
+        min_x -= width * 0.075
+        max_x += width * 0.075
+    width, height = size
+    scale = min(width / (max_x - min_x), height / (max_y - min_y)) if crop == "full" else height / (max_y - min_y)
+    center_x, center_y = (min_x + max_x) / 2, (min_y + max_y) / 2
+    supersample = 2
+    canvas = Image.new("RGB", (width * supersample, height * supersample), "white")
+    draw = ImageDraw.Draw(canvas)
+    # Camera-relative studio lighting makes shape readable at every azimuth.
+    light = _unit(_add(_mul(right, -0.40), _add(_mul(up, 0.68), _mul(toward, 0.80))))
+    faces = sorted(model.faces, key=lambda face: sum(_dot(p, toward) for p in face[0]))
+    for points, normal, tone in faces:
+        if _dot(normal, toward) < -0.08:
+            continue
+        coords = [(((_dot(p, right) - center_x) * scale + width / 2) * supersample,
+                   (height / 2 - (_dot(p, up) - center_y) * scale) * supersample)
+                  for p in points]
+        if max(p[1] for p in coords) < 0 or min(p[1] for p in coords) > height * supersample:
+            continue
+        diffuse = max(0, _dot(normal, light))
+        shade = round(tone * (0.54 + 0.55 * diffuse))
+        color = (shade, min(255, shade + 2), min(255, shade + 4))
+        draw.polygon(coords, fill=color)
+    return canvas.resize(size, Image.Resampling.LANCZOS)
+
+
+def _preview(paths):
+    card_w, card_h, padding = 360, 420, 20
+    sheet = Image.new("RGB", (card_w * 3 + padding * 4, card_h * 4 + padding * 5), "#eef0f3")
+    draw = ImageDraw.Draw(sheet)
+    try:
+        font = ImageFont.truetype("DejaVuSans.ttf", 19)
+    except OSError:
+        font = ImageFont.load_default(size=19)
+    for index, (key, path) in enumerate(paths.items()):
+        x = padding + index % 3 * (card_w + padding)
+        y = padding + index // 3 * (card_h + padding)
+        draw.rounded_rectangle((x, y, x + card_w, y + card_h), radius=12, fill="white")
+        draw.text((x + 16, y + 17), GUIDE_SPECS[key][0], fill="#283444", font=font)
+        with Image.open(path) as source:
+            thumbnail = source.copy()
+        thumbnail.thumbnail((card_w - 24, card_h - 66), Image.Resampling.LANCZOS)
+        sheet.paste(thumbnail, (x + (card_w - thumbnail.width) // 2,
+                                y + 52 + (card_h - 66 - thumbnail.height) // 2))
+    sheet.save(ASSET_DIR / "pose_preview.png", optimize=True)
+
+
+def ensure_guides(*, regenerate: bool = False) -> dict[str, Path]:
+    """Return the eleven bundled PNG paths; create any missing assets locally."""
+    ASSET_DIR.mkdir(parents=True, exist_ok=True)
+    paths = {key: ASSET_DIR / f"{key}.png" for key in GUIDE_SPECS}
+    models = {}
+    changed = False
+    for key, path in paths.items():
+        if path.is_file() and not regenerate:
+            continue
+        _, pose, azimuth, elevation, crop, size = GUIDE_SPECS[key]
+        if pose not in models:
+            models[pose] = {"standing": _standing, "knees": _knees, "prone": _prone}[pose]()
+        _render(models[pose], azimuth, elevation, crop, size, pose).save(path, optimize=True)
+        changed = True
+    if changed or not (ASSET_DIR / "pose_preview.png").is_file():
+        _preview(paths)
+    return paths
+
+
+def get_guide(key: str, width: int, height: int) -> Image.Image:
+    """Load one neutral RGB guide, resizing to the requested output dimensions."""
+    if key not in GUIDE_SPECS:
+        raise KeyError(f"Unknown pose guide: {key}")
+    if width <= 0 or height <= 0:
+        raise ValueError("Guide width and height must be positive")
+    path = ASSET_DIR / f"{key}.png"
+    if not path.is_file():
+        path = ensure_guides()[key]
+    with Image.open(path) as source:
+        result = source.convert("RGB")
+    if result.size != (width, height):
+        result = result.resize((width, height), Image.Resampling.LANCZOS)
+    return result
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--regenerate", action="store_true", help="Rebuild all bundled PNGs")
+    args = parser.parse_args()
+    for guide_key, guide_path in ensure_guides(regenerate=args.regenerate).items():
+        print(f"{guide_key}: {guide_path}")
+    print(f"Preview: {ASSET_DIR / 'pose_preview.png'}")

qwenimage/qwen_fa3_processor.py

@@ -1,142 +0,0 @@
-"""
-Paired with a good language model. Thanks!
-"""
-
-import torch
-from typing import Optional, Tuple
-from diffusers.models.transformers.transformer_qwenimage import apply_rotary_emb_qwen
-
-try:
-    from kernels import get_kernel
-    _k = get_kernel("kernels-community/vllm-flash-attn3")
-    _flash_attn_func = _k.flash_attn_func
-except Exception as e:
-    _flash_attn_func = None
-    _kernels_err = e
-
-
-def _ensure_fa3_available():
-    if _flash_attn_func is None:
-        raise ImportError(
-            "FlashAttention-3 via Hugging Face `kernels` is required. "
-            "Tried `get_kernel('kernels-community/vllm-flash-attn3')` and failed with:\n"
-            f"{_kernels_err}"
-        )
-
-@torch.library.custom_op("flash::flash_attn_func", mutates_args=())
-def flash_attn_func(
-    q: torch.Tensor, k: torch.Tensor, v: torch.Tensor, causal: bool = False
-) -> torch.Tensor:
-    outputs, lse = _flash_attn_func(q, k, v, causal=causal)
-    return outputs
-
-@flash_attn_func.register_fake
-def _(q, k, v, **kwargs):
-    # two outputs:
-    # 1. output: (batch, seq_len, num_heads, head_dim)
-    # 2. softmax_lse: (batch, num_heads, seq_len) with dtype=torch.float32
-    meta_q = torch.empty_like(q).contiguous()
-    return meta_q #, q.new_empty((q.size(0), q.size(2), q.size(1)), dtype=torch.float32)
-
-
-class QwenDoubleStreamAttnProcessorFA3:
-    """
-    FA3-based attention processor for Qwen double-stream architecture.
-    Computes joint attention over concatenated [text, image] streams using vLLM FlashAttention-3
-    accessed via Hugging Face `kernels`.
-
-    Notes / limitations:
-    - General attention masks are not supported here (FA3 path). `is_causal=False` and no arbitrary mask.
-    - Optional windowed attention / sink tokens / softcap can be plumbed through if you use those features.
-    - Expects an available `apply_rotary_emb_qwen` in scope (same as your non-FA3 processor).
-    """
-
-    _attention_backend = "fa3"  # for parity with your other processors, not used internally
-
-    def __init__(self):
-        _ensure_fa3_available()
-
-    @torch.no_grad()
-    def __call__(
-        self,
-        attn,  # Attention module with to_q/to_k/to_v/add_*_proj, norms, to_out, to_add_out, and .heads
-        hidden_states: torch.FloatTensor,                 # (B, S_img, D_model)  image stream
-        encoder_hidden_states: torch.FloatTensor = None,  # (B, S_txt, D_model)  text stream
-        encoder_hidden_states_mask: torch.FloatTensor = None,  # unused in FA3 path
-        attention_mask: Optional[torch.FloatTensor] = None,    # unused in FA3 path
-        image_rotary_emb: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,  # (img_freqs, txt_freqs)
-    ) -> Tuple[torch.FloatTensor, torch.FloatTensor]:
-        if encoder_hidden_states is None:
-            raise ValueError("QwenDoubleStreamAttnProcessorFA3 requires encoder_hidden_states (text stream).")
-        if attention_mask is not None:
-            # FA3 kernel path here does not consume arbitrary masks; fail fast to avoid silent correctness issues.
-            raise NotImplementedError("attention_mask is not supported in this FA3 implementation.")
-
-        _ensure_fa3_available()
-
-        B, S_img, _ = hidden_states.shape
-        S_txt = encoder_hidden_states.shape[1]
-
-        # ---- QKV projections (image/sample stream) ----
-        img_q = attn.to_q(hidden_states)   # (B, S_img, D)
-        img_k = attn.to_k(hidden_states)
-        img_v = attn.to_v(hidden_states)
-
-        # ---- QKV projections (text/context stream) ----
-        txt_q = attn.add_q_proj(encoder_hidden_states)  # (B, S_txt, D)
-        txt_k = attn.add_k_proj(encoder_hidden_states)
-        txt_v = attn.add_v_proj(encoder_hidden_states)
-
-        # ---- Reshape to (B, S, H, D_h) ----
-        H = attn.heads
-        img_q = img_q.unflatten(-1, (H, -1))
-        img_k = img_k.unflatten(-1, (H, -1))
-        img_v = img_v.unflatten(-1, (H, -1))
-
-        txt_q = txt_q.unflatten(-1, (H, -1))
-        txt_k = txt_k.unflatten(-1, (H, -1))
-        txt_v = txt_v.unflatten(-1, (H, -1))
-
-        # ---- Q/K normalization (per your module contract) ----
-        if getattr(attn, "norm_q", None) is not None:
-            img_q = attn.norm_q(img_q)
-        if getattr(attn, "norm_k", None) is not None:
-            img_k = attn.norm_k(img_k)
-        if getattr(attn, "norm_added_q", None) is not None:
-            txt_q = attn.norm_added_q(txt_q)
-        if getattr(attn, "norm_added_k", None) is not None:
-            txt_k = attn.norm_added_k(txt_k)
-
-        # ---- RoPE (Qwen variant) ----
-        if image_rotary_emb is not None:
-            img_freqs, txt_freqs = image_rotary_emb
-            # expects tensors shaped (B, S, H, D_h)
-            img_q = apply_rotary_emb_qwen(img_q, img_freqs, use_real=False)
-            img_k = apply_rotary_emb_qwen(img_k, img_freqs, use_real=False)
-            txt_q = apply_rotary_emb_qwen(txt_q, txt_freqs, use_real=False)
-            txt_k = apply_rotary_emb_qwen(txt_k, txt_freqs, use_real=False)
-
-        # ---- Joint attention over [text, image] along sequence axis ----
-        # Shapes: (B, S_total, H, D_h)
-        q = torch.cat([txt_q, img_q], dim=1)
-        k = torch.cat([txt_k, img_k], dim=1)
-        v = torch.cat([txt_v, img_v], dim=1)
-
-        # FlashAttention-3 path expects (B, S, H, D_h) and returns (out, softmax_lse)
-        out = flash_attn_func(q, k, v, causal=False)  # out: (B, S_total, H, D_h)
-
-        # ---- Back to (B, S, D_model) ----
-        out = out.flatten(2, 3).to(q.dtype)
-
-        # Split back to text / image segments
-        txt_attn_out = out[:, :S_txt, :]
-        img_attn_out = out[:, S_txt:, :]
-
-        # ---- Output projections ----
-        img_attn_out = attn.to_out[0](img_attn_out)
-        if len(attn.to_out) > 1:
-            img_attn_out = attn.to_out[1](img_attn_out)  # dropout if present
-
-        txt_attn_out = attn.to_add_out(txt_attn_out)
-
-        return img_attn_out, txt_attn_out

requirements.txt

@@ -1,35 +1,9 @@
-# torch は **絶対にピンしない**。
-#
-# 一度 `--extra-index-url .../cu130` + `torch==2.11.0` を指定したところ、ZeroGPU の
-# ベースイメージが用意する torch と食い違い、GPU 取得時に
-#   RuntimeError: NVML_SUCCESS == r INTERNAL ASSERT FAILED at CUDACachingAllocator.cpp:1165
-# で必ず落ちた (spaces が pin_memory().cuda() でモデルを転送する箇所)。
-# ZeroGPU のベースイメージが入れる torch をそのまま使うこと。
-#
-# 依存の組み合わせは、同じ Qwen-Image-Edit-2511 + 同じ角度 LoRA で実際に稼働している
-# multimodalart/qwen-image-multiple-angles-3d-camera に合わせてある。
-diffusers==0.39.0
-transformers
+# HF Gradio/ZeroGPU supplies torch, spaces and gradio. Keep those environment versions.
+# Pinned upstream implementation includes QwenImage21 + saved Turbo sigma schedules.
+git+https://github.com/huggingface/diffusers.git@85c9fa4caee33d1c5b473395784471d2d7957c1b
+transformers>=5.17.0,<6
 accelerate
 safetensors
-sentencepiece
 peft
 torchvision
-
-# FlashAttention-3 をカーネルとして取得する。
-# kernels 0.15 以降は get_kernel() に version=/revision= が必須になり、
-# vendoring している qwen_fa3_processor.py の呼び出しが通らなくなるため 0.15 未満に固定。
-kernels<0.15
-
-# fp8 動的量子化 (VRAM 削減 + 約 1.2 倍の高速化)
-torchao==0.16.0
-
-# タガーは CPU 実行 (ZeroGPU クォータを消費しない)
-onnxruntime
 pillow
-numpy
-
-# `spaces` と `gradio` は書かないこと。
-# HF Spaces はビルドコマンドで両方を強制注入する:
-#   pip install -r requirements.txt "torch<=2.11.0" gradio[oauth,mcp]==5.49.1 ... spaces==0.51.1
-# requirements.txt 側で別バージョンを指定すると ResolutionImpossible でビルドが落ちる。

tagging.py

@@ -1,441 +0,0 @@
-"""LoRA 学習用キャプション生成 (WD Tagger v3 / OppaiOracle の比較付き).
-
-どちらのタガーも ONNX なので **onnxruntime の CPU 実行**にしてある。
-ZeroGPU のクォータは要求 duration ぶんそのまま消費されるため、タグ付けを GPU 側で
-やると生成できる視点数が直接減る。CPU で回せばクォータ消費はゼロになる。
-
-キャプションの構成:
-    {トリガーワード}, {構図の確定タグ}, {タガーが推定したタグ}
-
-構図タグ (full body / from behind / from above / cowboy shot など) は
-views.py のカメラパラメータから決定的に注入する。タガーは構図を安定して当てられない
-ので、既知の情報を推論に任せない方が精度が高い。
-"""
-
-from __future__ import annotations
-
-import csv
-import json
-import threading
-from dataclasses import dataclass
-from typing import Dict, List, Sequence, Tuple
-
-import numpy as np
-from huggingface_hub import hf_hub_download
-from PIL import Image
-
-# --- タガー定義 -------------------------------------------------------------
-
-WD_REPO = "SmilingWolf/wd-swinv2-tagger-v3"
-WD_DEFAULT_THRESHOLD = 0.35
-
-OPPAI_REPO = "Grio43/OppaiOracle"
-OPPAI_SUBDIR = "V1.1_onnx"
-# pr_thresholds.json の micro.f1_optimal.threshold。WD の 0.35 とは桁が違うので
-# 共通の既定値を使ってはいけない。
-OPPAI_DEFAULT_THRESHOLD = 0.805
-OPPAI_SKIP_INDICES = (0, 1)  # <PAD>, <UNK>
-
-#: Danbooru の rating / character カテゴリ。キャラクター LoRA の学習では
-#: 通常どちらもキャプションから外す (rating はノイズ、character 名は固有名詞)。
-WD_KEEP_CATEGORIES = (0,)
-
-#: OppaiOracle は全タグが general カテゴリ扱いで、rating タグも同じ空間に入っている
-#: (実測で `rating:general` が確信度 1.00 で出る)。名前で落とす。
-META_TAG_PREFIXES = ("rating:",)
-
-#: 画像そのものの素性を表すメタタグ。学習キャプションに残すとノイズにしかならない。
-META_TAGS = frozenset(
-    {
-        "highres", "absurdres", "incredibly absurdres", "lowres", "hugefilesize",
-        "commentary", "commentary request", "english commentary", "chinese commentary",
-        "translated", "translation request", "check translation",
-        "bad id", "bad pixiv id", "bad twitter id", "bad link",
-        "jpeg artifacts", "scan", "official art", "artist request", "character request",
-        "md5 mismatch", "resolution mismatch", "source larger", "non-web source",
-        "third-party edit", "revision", "duplicate", "image sample",
-    }
-)
-
-
-def is_meta_tag(tag: str) -> bool:
-    norm = _normalize(tag)
-    return norm in META_TAGS or any(norm.startswith(p) for p in META_TAG_PREFIXES)
-
-
-def format_tag(tag: str) -> str:
-    """Danbooru タグを kohya-ss のキャプション表記に整える。"""
-    if tag in ("^_^", ">_<", "o_o", "0_0", "|_|", "._.", "\\m/", "^^^"):
-        return tag
-    return tag.replace("_", " ").replace("(", r"\(").replace(")", r"\)")
-
-
-def _normalize(tag: str) -> str:
-    """重複判定・除外判定に使う正規形。"""
-    return tag.replace("_", " ").replace("\\", "").strip().lower()
-
-
-@dataclass
-class TagResult:
-    tagger: str
-    tags: List[Tuple[str, float]]  #: (整形済みタグ, 確信度) を確信度降順で
-
-    def names(self) -> List[str]:
-        return [t for t, _ in self.tags]
-
-
-class _OnnxTagger:
-    """ONNX タガーの共通土台。セッションはプロセス内で 1 回だけ作る。"""
-
-    name = "base"
-    default_threshold = 0.35
-    #: UI の閾値スライダー範囲 (min, max, step)。両タガーはスコア分布が大きく違うため、
-    #: 共通のレンジを使うと片方が実用外の値しか選べなくなる。
-    threshold_range = (0.05, 0.95, 0.01)
-
-    def __init__(self) -> None:
-        self._session = None
-        self._tags: List[str] = []
-        self._categories: List[int] = []
-        self._lock = threading.Lock()
-
-    def _build(self) -> None:  # pragma: no cover - サブクラスで実装
-        raise NotImplementedError
-
-    def ensure_loaded(self) -> None:
-        if self._session is not None:
-            return
-        with self._lock:
-            if self._session is None:
-                self._build()
-
-    def _preprocess(self, image: Image.Image) -> Dict[str, np.ndarray]:  # pragma: no cover
-        raise NotImplementedError
-
-    def predict(
-        self,
-        image: Image.Image,
-        threshold: float | None = None,
-        drop_meta: bool = True,
-        max_tags: int = 60,
-    ) -> TagResult:
-        self.ensure_loaded()
-        thr = self.default_threshold if threshold is None else float(threshold)
-        probs = self._session.run(None, self._preprocess(image))[0][0]
-
-        picked: List[Tuple[str, float]] = []
-        for idx in np.nonzero(probs >= thr)[0]:
-            if idx >= len(self._tags):
-                continue
-            raw = self._tags[idx]
-            if not raw:
-                continue
-            if self._categories and self._categories[idx] not in WD_KEEP_CATEGORIES:
-                continue
-            if drop_meta and is_meta_tag(raw):
-                continue
-            picked.append((format_tag(raw), float(probs[idx])))
-        picked.sort(key=lambda x: x[1], reverse=True)
-        # 閾値を下げすぎたときに数千タグが出てキャプションが壊れるのを防ぐ
-        return TagResult(self.name, picked[:max_tags])
-
-
-class WDTagger(_OnnxTagger):
-    """SmilingWolf/wd-*-tagger-v3.
-
-    ONNX 入力は NHWC・BGR・0-255 のまま (正規化はグラフ内)。余白は白で
-    正方形にパディングしてからリサイズする、というのが SmilingWolf 系の作法。
-    """
-
-    name = "WD Tagger v3"
-    default_threshold = WD_DEFAULT_THRESHOLD
-    threshold_range = (0.10, 0.70, 0.01)
-
-    def __init__(self, repo: str = WD_REPO) -> None:
-        super().__init__()
-        self.repo = repo
-        self._size = 448
-        self._channels_last = True
-        self._input_name = "input"
-
-    def _build(self) -> None:
-        import onnxruntime as ort
-
-        model_path = hf_hub_download(self.repo, "model.onnx")
-        tags_path = hf_hub_download(self.repo, "selected_tags.csv")
-
-        with open(tags_path, "r", encoding="utf-8") as fh:
-            rows = list(csv.DictReader(fh))
-        self._tags = [r["name"] for r in rows]
-        self._categories = [int(r["category"]) for r in rows]
-
-        session = ort.InferenceSession(model_path, providers=["CPUExecutionProvider"])
-        inp = session.get_inputs()[0]
-        self._input_name = inp.name
-        shape = inp.shape
-        # [N, H, W, 3] なら NHWC、[N, 3, H, W] なら NCHW
-        self._channels_last = len(shape) == 4 and shape[-1] == 3
-        dim = shape[1] if self._channels_last else shape[2]
-        if isinstance(dim, int) and dim > 0:
-            self._size = dim
-        self._session = session
-        print(f"[tagging] {self.name} loaded: {len(self._tags)} tags, input={inp.name}{shape}")
-
-    def _preprocess(self, image: Image.Image) -> Dict[str, np.ndarray]:
-        img = image.convert("RGBA")
-        canvas = Image.new("RGBA", img.size, (255, 255, 255))
-        canvas.alpha_composite(img)
-        img = canvas.convert("RGB")
-
-        side = max(img.size)
-        square = Image.new("RGB", (side, side), (255, 255, 255))
-        square.paste(img, ((side - img.size[0]) // 2, (side - img.size[1]) // 2))
-        square = square.resize((self._size, self._size), Image.BICUBIC)
-
-        arr = np.asarray(square, dtype=np.float32)[:, :, ::-1]  # RGB -> BGR
-        if not self._channels_last:
-            arr = arr.transpose(2, 0, 1)
-        return {self._input_name: np.expand_dims(arr, axis=0)}
-
-
-class OppaiOracleTagger(_OnnxTagger):
-    """Grio43/OppaiOracle V1.1.
-
-    前処理はグラフ外。preprocessing.json の指定どおり
-    letterbox (アスペクト比維持 + (114,114,114) パディング) → (x/255 - 0.5) / 0.5。
-    `padding_mask` (True = パディング画素) を第 2 入力として渡す必要がある。
-    """
-
-    name = "OppaiOracle V1.1"
-    default_threshold = OPPAI_DEFAULT_THRESHOLD
-    # 実測: 0.805 で 21 タグ / 0.5 で 445 タグ / 0.35 で 2768 タグ。
-    # WD と同じレンジにすると実用外の領域しか触れなくなるので分けてある。
-    threshold_range = (0.60, 0.97, 0.005)
-
-    def __init__(self) -> None:
-        super().__init__()
-        self._size = 448
-        self._pad = (114, 114, 114)
-        self._mean = 0.5
-        self._std = 0.5
-
-    def _build(self) -> None:
-        import onnxruntime as ort
-
-        model_path = hf_hub_download(OPPAI_REPO, f"{OPPAI_SUBDIR}/model.onnx")
-        tags_path = hf_hub_download(OPPAI_REPO, f"{OPPAI_SUBDIR}/selected_tags.csv")
-        prep_path = hf_hub_download(OPPAI_REPO, f"{OPPAI_SUBDIR}/preprocessing.json")
-
-        with open(prep_path, "r", encoding="utf-8") as fh:
-            prep = json.load(fh)
-        self._size = int(prep.get("image_size", 448))
-        self._pad = tuple(prep.get("pad_color_rgb", [114, 114, 114]))
-        self._mean = float(prep.get("normalize_mean", [0.5])[0])
-        self._std = float(prep.get("normalize_std", [0.5])[0])
-
-        with open(tags_path, "r", encoding="utf-8") as fh:
-            rows = list(csv.DictReader(fh))
-        self._tags = [r["name"] for r in rows]
-        # 全タグが general カテゴリなのでカテゴリ絞り込みはしない
-        self._categories = []
-        for idx in OPPAI_SKIP_INDICES:
-            if idx < len(self._tags):
-                self._tags[idx] = ""  # <PAD> / <UNK> は出力しない
-
-        self._session = ort.InferenceSession(model_path, providers=["CPUExecutionProvider"])
-        names = [i.name for i in self._session.get_inputs()]
-        print(f"[tagging] {self.name} loaded: {len(self._tags)} tags, inputs={names}")
-
-    def _preprocess(self, image: Image.Image) -> Dict[str, np.ndarray]:
-        img = image.convert("RGB")
-        w, h = img.size
-        scale = self._size / max(w, h)
-        nw, nh = max(1, round(w * scale)), max(1, round(h * scale))
-        resized = img.resize((nw, nh), Image.BICUBIC)
-
-        canvas = Image.new("RGB", (self._size, self._size), self._pad)
-        off_x, off_y = (self._size - nw) // 2, (self._size - nh) // 2
-        canvas.paste(resized, (off_x, off_y))
-
-        arr = np.asarray(canvas, dtype=np.float32) / 255.0
-        arr = (arr - self._mean) / self._std
-        arr = arr.transpose(2, 0, 1)[None]  # NCHW
-
-        mask = np.ones((self._size, self._size), dtype=bool)  # True = パディング
-        mask[off_y : off_y + nh, off_x : off_x + nw] = False
-        return {"pixel_values": arr, "padding_mask": mask[None]}
-
-
-_WD = WDTagger()
-_OPPAI = OppaiOracleTagger()
-
-TAGGERS: Dict[str, _OnnxTagger] = {
-    "wd": _WD,
-    "oppai": _OPPAI,
-}
-TAGGER_LABELS = {
-    "wd": "WD Tagger v3 (SmilingWolf)",
-    "oppai": "OppaiOracle V1.1 (Grio43)",
-}
-
-
-# --- キャプション組み立て ---------------------------------------------------
-
-
-#: 互いに排他的なタグ群。タガーは「うつ伏せの視点」を条件付け元の立ち絵から
-#: 推定してしまい `standing` を返すことがある (実測)。確定タグ側で構図が決まって
-#: いる群については、タガー由来の同じ群のタグを落として矛盾を防ぐ。
-CONFLICT_GROUPS: Tuple[frozenset, ...] = (
-    # フレーミング
-    frozenset(
-        {
-            "full body", "upper body", "portrait", "close-up", "cowboy shot",
-            "lower body", "feet out of frame", "head out of frame",
-        }
-    ),
-    # カメラ方向
-    frozenset(
-        {
-            "from behind", "from side", "from above", "from below", "from front",
-            "profile", "facing away", "facing viewer", "dutch angle",
-        }
-    ),
-    # ポーズ
-    frozenset(
-        {
-            "standing", "sitting", "lying", "on stomach", "on back", "on side",
-            "squatting", "kneeling", "walking", "running", "all fours",
-            "hugging own legs", "knees up", "crossed legs", "wariza", "yokozuwari",
-            "seiza", "arms up", "leaning forward",
-        }
-    ),
-)
-
-
-def _conflicting_keys(fixed_norm: set) -> set:
-    """確定タグが触れている群のうち、確定タグ自身には無いタグの正規形。"""
-    blocked: set = set()
-    for group in CONFLICT_GROUPS:
-        if fixed_norm & group:
-            blocked |= group - fixed_norm
-    return blocked
-
-
-def build_caption(
-    fixed_tags: Sequence[str],
-    predicted: Sequence[str],
-    trigger: str = "",
-    exclude: Sequence[str] | str = (),
-) -> str:
-    """確定タグとタガー出力をマージして 1 行のキャプションにする。
-
-    確定タグを先に置くのは、kohya-ss の caption dropout / shuffle を使わない
-    運用で先頭ほど強く効くため。
-    """
-    if isinstance(exclude, str):
-        exclude = parse_exclude(exclude)
-    # ユーザー指定の除外は確定タグにも効かせる (白背景を外したい等のため)
-    user_excluded = {_normalize(e) for e in exclude if e.strip()}
-    # 矛盾による除外はタガー出力にだけ効かせる
-    conflict_blocked = _conflicting_keys({_normalize(t) for t in fixed_tags})
-
-    seen: set = set()
-    out: List[str] = []
-
-    trigger = (trigger or "").strip()
-    if trigger:
-        out.append(trigger)
-        seen.add(_normalize(trigger))
-
-    for tag in fixed_tags:
-        key = _normalize(tag)
-        if not key or key in seen or key in user_excluded:
-            continue
-        seen.add(key)
-        out.append(tag)
-
-    for tag in predicted:
-        key = _normalize(tag)
-        if not key or key in seen or key in user_excluded or key in conflict_blocked:
-            continue
-        seen.add(key)
-        out.append(tag)
-
-    return ", ".join(out)
-
-
-def parse_exclude(text: str) -> List[str]:
-    return [t.strip() for t in (text or "").replace("\n", ",").split(",") if t.strip()]
-
-
-def compare(results: Dict[str, TagResult]) -> Dict[str, List[str]]:
-    """タガー間の共通タグ / 片方だけのタグを求める。"""
-    if len(results) < 2:
-        only = next(iter(results.values())).names() if results else []
-        return {"common": only, "wd_only": [], "oppai_only": []}
-
-    wd = results.get("wd")
-    op = results.get("oppai")
-    wd_set = {_normalize(t): t for t in (wd.names() if wd else [])}
-    op_set = {_normalize(t): t for t in (op.names() if op else [])}
-    common = [wd_set[k] for k in wd_set if k in op_set]
-    return {
-        "common": common,
-        "wd_only": [wd_set[k] for k in wd_set if k not in op_set],
-        "oppai_only": [op_set[k] for k in op_set if k not in wd_set],
-    }
-
-
-def comparison_markdown(per_view: Dict[str, Dict[str, TagResult]]) -> str:
-    """ZIP に同梱する比較レポート。"""
-    lines = [
-        "# キャプション比較: WD Tagger v3 vs OppaiOracle V1.1",
-        "",
-        "同一画像に両タガーを適用した結果。`共通` が多いほど両者の判断が一致している。",
-        "どちらも Danbooru 系のアニメタガーなので、実写寄りの参照画像ではタグ品質が落ちる。",
-        "",
-        "| 視点 | 共通 | WD のみ | OppaiOracle のみ | WD 総数 | Oppai 総数 |",
-        "|---|---|---|---|:---:|:---:|",
-    ]
-    totals = {"common": 0, "wd_only": 0, "oppai_only": 0, "wd": 0, "oppai": 0}
-    for view_key, results in per_view.items():
-        cmp = compare(results)
-        wd_n = len(results["wd"].tags) if "wd" in results else 0
-        op_n = len(results["oppai"].tags) if "oppai" in results else 0
-        totals["common"] += len(cmp["common"])
-        totals["wd_only"] += len(cmp["wd_only"])
-        totals["oppai_only"] += len(cmp["oppai_only"])
-        totals["wd"] += wd_n
-        totals["oppai"] += op_n
-        lines.append(
-            f"| {view_key} | {', '.join(cmp['common']) or '-'} | "
-            f"{', '.join(cmp['wd_only']) or '-'} | {', '.join(cmp['oppai_only']) or '-'} | "
-            f"{wd_n} | {op_n} |"
-        )
-
-    lines += [
-        "",
-        "## 合計",
-        "",
-        f"- 共通タグ: {totals['common']}",
-        f"- WD のみ: {totals['wd_only']}",
-        f"- OppaiOracle のみ: {totals['oppai_only']}",
-        f"- 総タグ数: WD {totals['wd']} / OppaiOracle {totals['oppai']}",
-        "",
-        "## 閾値について",
-        "",
-        f"- WD Tagger v3 の既定閾値は {WD_DEFAULT_THRESHOLD}",
-        f"- OppaiOracle の既定閾値は {OPPAI_DEFAULT_THRESHOLD} "
-        "(pr_thresholds.json の micro.f1_optimal)",
-        "",
-        "両者はスコアの分布が大きく違うため、同じ閾値で比べると不公平になる。",
-        "タグ数を揃えて比べたい場合は UI の閾値スライダーで調整すること。",
-        "",
-        "## 既知の傾向",
-        "",
-        "- OppaiOracle はモデルカード自身が「色名タグはソース由来のノイズが多い」"
-        "「本来 50+ 付くべきところ平均 28 タグしか付いていない」と明記している。",
-        "- 構図タグ (from behind / from above / cowboy shot など) は"
-        "どちらのタガーも安定しないため、本 Space ではカメラパラメータから決定的に注入している。",
-    ]
-    return "\n".join(lines)

tests/test_core.py

@@ -0,0 +1,321 @@
+"""CPU-only behavioral checks. These do not validate model speed or image quality."""
+import contextlib
+import io
+from pathlib import Path
+import shutil
+import sys
+import unittest
+import zipfile
+
+from PIL import Image, ImageDraw
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from core import (build_zip, conditioning_reference, prepare_reference,
+                  requested_seconds, rgb_on_white, run_batch)
+from views import BY_KEY, DEFAULT_KEYS, SIZES, VIEWS, validate_keys
+
+
+class FakeClock:
+    def __init__(self):
+        self.now = 0.0
+
+    def __call__(self):
+        return self.now
+
+    def advance(self, seconds):
+        self.now += seconds
+
+
+class CoreTests(unittest.TestCase):
+    def setUp(self):
+        self.reference = Image.new("RGB", (24, 32), "red")
+        self.guides = {key: Image.new("RGB", (12, 16), (index, 0, 0))
+                       for index, key in enumerate(DEFAULT_KEYS)}
+        self.clock = FakeClock()
+
+    def run_generation(self, generate_one, keys=None, **overrides):
+        options = dict(generate_one=generate_one, reference=self.reference,
+                       keys=DEFAULT_KEYS if keys is None else keys,
+                       guide_images=self.guides, resolution="fast", seed=123,
+                       extra="", angles=False, budget_seconds=100,
+                       clock=self.clock)
+        options.update(overrides)
+        with contextlib.redirect_stdout(io.StringIO()):
+            return run_batch(**options)
+
+    def test_exactly_the_eleven_requested_views(self):
+        expected = ["full_front", "full_left", "full_right", "full_back",
+                    "cowboy_front", "cowboy_back", "upper_front", "face_front",
+                    "knees_front", "knees_back", "prone_back"]
+        self.assertEqual(DEFAULT_KEYS, expected)
+        self.assertEqual(len(VIEWS), 11)
+        self.assertEqual(len(BY_KEY), 11)
+        self.assertEqual(validate_keys(["full_front", "face_front", "full_front"]),
+                         ["full_front", "face_front"])
+        for invalid in ([], ["unknown"], ["full_front", "unknown"]):
+            with self.subTest(invalid=invalid), self.assertRaises(ValueError):
+                validate_keys(invalid)
+
+    def test_each_view_uses_original_identity_and_its_own_guide(self):
+        calls = []
+        generated = []
+
+        def generate(**kwargs):
+            calls.append(kwargs)
+            output = Image.new("RGB", (8, 8), (0, len(calls), 0))
+            generated.append(output)
+            self.clock.advance(0.25)
+            return output
+
+        result = self.run_generation(generate, crop_close_views=True)
+        self.assertEqual(len(calls), 11, "No extra anchor generations are permitted")
+        self.assertEqual(list(result.images), DEFAULT_KEYS)
+        self.assertEqual(len(result.timings), 11)
+        self.assertEqual(result.stop_reason, "")
+        for index, (key, call) in enumerate(zip(DEFAULT_KEYS, calls)):
+            with self.subTest(key=key):
+                self.assertEqual(len(call["image"]), 2)
+                if key in ("cowboy_front", "cowboy_back", "upper_front", "face_front"):
+                    source = call["image"][0]
+                    self.assertIsNot(source, self.reference)
+                    self.assertEqual(source.size, (call["width"], call["height"]))
+                    self.assertEqual(source.getpixel((source.width // 2, source.height // 2)),
+                                     (255, 0, 0), "Crop must retain original red identity reference")
+                else:
+                    self.assertIs(call["image"][0], self.reference)
+                self.assertTrue(all(call["image"][0] is not output for output in generated))
+                self.assertIs(call["image"][1], self.guides[key])
+                self.assertIs(result.images[key], generated[index])
+                self.assertEqual((call["width"], call["height"]),
+                                 SIZES["fast"][BY_KEY[key].shape])
+                self.assertIn("Image 2", call["prompt"])
+                self.assertEqual(result.timings[index]["references"], 2)
+
+    def test_guides_can_be_disabled_without_an_extra_generation(self):
+        calls = []
+
+        def generate(**kwargs):
+            calls.append(kwargs)
+            return Image.new("RGB", (8, 8))
+
+        result = self.run_generation(generate, keys=["full_front"], guide_images=None)
+        self.assertEqual(len(calls), 1)
+        self.assertEqual(calls[0]["image"], [self.reference])
+        self.assertNotIn("Image 2", calls[0]["prompt"])
+        self.assertEqual(result.timings[0]["references"], 1)
+
+    def test_crop_is_disabled_by_default_for_all_views(self):
+        calls = []
+
+        def generate(**kwargs):
+            calls.append(kwargs)
+            return Image.new("RGB", (8, 8))
+
+        self.run_generation(generate)
+        self.assertEqual(len(calls), 11)
+        self.assertTrue(all(call["image"][0] is self.reference for call in calls))
+
+    def test_per_view_seed_stays_the_same_for_subsets_and_reordering(self):
+        def seeds_for(keys):
+            received = []
+
+            def generate(**kwargs):
+                received.append(kwargs["seed"])
+                return Image.new("RGB", (8, 8))
+
+            self.run_generation(generate, keys=keys, seed=2**31 - 3)
+            return dict(zip(keys, received))
+
+        all_seeds = seeds_for(DEFAULT_KEYS)
+        subset = ["prone_back", "full_front", "face_front"]
+        self.assertEqual(seeds_for(subset), {key: all_seeds[key] for key in subset})
+        self.assertEqual(all_seeds["full_front"], 2**31 - 3)
+        self.assertEqual(all_seeds["full_back"], 0)
+        self.assertEqual(len(set(all_seeds.values())), 11)
+
+    def test_generation_failure_keeps_completed_results(self):
+        completed = Image.new("RGB", (8, 8), "blue")
+        calls = []
+
+        def generate(**kwargs):
+            calls.append(kwargs)
+            if len(calls) == 2:
+                raise RuntimeError("simulated backend error")
+            return completed
+
+        result = self.run_generation(generate)
+        self.assertEqual(len(calls), 2)
+        self.assertEqual(list(result.images), ["full_front"])
+        self.assertIs(result.images["full_front"], completed)
+        self.assertEqual(len(result.timings), 1)
+        self.assertIn(BY_KEY["full_left"].label, result.stop_reason)
+        self.assertTrue(result.stop_reason)
+
+    def test_denoising_budget_expiry_keeps_previous_result(self):
+        calls = []
+
+        def generate(**kwargs):
+            calls.append(kwargs)
+            self.clock.advance(1 if len(calls) == 1 else 13)
+            kwargs["check_budget"]()
+            return Image.new("RGB", (8, 8))
+
+        result = self.run_generation(generate, budget_seconds=20)
+        self.assertEqual(len(calls), 2)
+        self.assertEqual(list(result.images), ["full_front"])
+        self.assertEqual(len(result.timings), 1)
+        self.assertTrue(result.stop_reason)
+
+    def test_insufficient_remaining_time_stops_before_starting_next_view(self):
+        calls = []
+
+        def generate(**kwargs):
+            calls.append(kwargs)
+            self.clock.advance(6)
+            return Image.new("RGB", (8, 8))
+
+        result = self.run_generation(generate, budget_seconds=20)
+        self.assertEqual(len(calls), 1)
+        self.assertEqual(list(result.images), ["full_front"])
+        self.assertTrue(result.stop_reason)
+
+    def test_empty_budget_does_not_start_generation(self):
+        def never_called(**kwargs):
+            self.fail("Generation must not start when the budget is exhausted")
+
+        result = self.run_generation(never_called, budget_seconds=0)
+        self.assertEqual(result.images, {})
+        self.assertTrue(result.stop_reason)
+
+    def test_requested_budget_obeys_configured_ceiling(self):
+        self.assertEqual(requested_seconds(DEFAULT_KEYS), 110)
+        self.assertEqual(requested_seconds(DEFAULT_KEYS, maximum=60), 60)
+        self.assertEqual(requested_seconds(["face_front"]), 45)
+        self.assertEqual(requested_seconds(["face_front", "face_front"]), 45)
+
+    def test_single_view_budget_allows_work_after_startup_and_decode_reserves(self):
+        # Artificial 20-second generation: a regression check, not a speed estimate.
+        # The backend reserves 15 seconds for ZeroGPU startup/result transport.
+        def generate(**kwargs):
+            self.clock.advance(20)
+            kwargs["check_budget"]()
+            return Image.new("RGB", (8, 8))
+
+        keys = ["face_front"]
+        result = self.run_generation(generate, keys=keys,
+                                     budget_seconds=requested_seconds(keys) - 15)
+        self.assertEqual(list(result.images), keys)
+        self.assertEqual(result.stop_reason, "")
+
+    def test_zip_contains_only_selected_completed_pngs_no_captions(self):
+        completed = {"full_front": Image.new("RGBA", (12, 16), "red"),
+                     "face_front": Image.new("RGB", (16, 16), "blue"),
+                     "prone_back": Image.new("RGB", (16, 12), "green")}
+        # One selected image has not been generated; one completed image is unselected.
+        path = build_zip(completed, ["face_front", "full_left", "full_front", "face_front"])
+        self.assertIsNotNone(path)
+        self.addCleanup(shutil.rmtree, Path(path).parent)
+        with zipfile.ZipFile(path) as archive:
+            self.assertEqual(archive.namelist(),
+                             ["dataset/08_face_front.png", "dataset/01_full_front.png"])
+            for name in archive.namelist():
+                with self.subTest(name=name), Image.open(io.BytesIO(archive.read(name))) as image:
+                    image.load()
+                    self.assertEqual(image.format, "PNG")
+                    self.assertEqual(image.mode, "RGB")
+                    self.assertEqual(image.getpixel((0, 0)),
+                                     (0, 0, 255) if "face_front" in name else (255, 0, 0))
+
+    def test_zip_has_no_file_when_selection_has_no_completed_images(self):
+        self.assertIsNone(build_zip({}, DEFAULT_KEYS))
+        self.assertIsNone(build_zip({"full_front": self.reference}, ["face_front"]))
+
+    def test_zip_composites_transparent_generated_pixels_on_white(self):
+        source = Image.new("RGBA", (2, 1), (255, 0, 0, 128))
+        source.putpixel((1, 0), (0, 0, 0, 0))
+        path = build_zip({"full_front": source}, ["full_front"])
+        self.addCleanup(shutil.rmtree, Path(path).parent)
+        with zipfile.ZipFile(path) as archive:
+            with Image.open(io.BytesIO(archive.read("dataset/01_full_front.png"))) as image:
+                self.assertEqual(image.mode, "RGB")
+                self.assertEqual(image.getpixel((0, 0)), (255, 127, 127))
+                self.assertEqual(image.getpixel((1, 0)), (255, 255, 255))
+        self.assertEqual(source.getpixel((1, 0)), (0, 0, 0, 0))
+
+    def test_close_view_crops_use_foreground_height_and_exclude_lower_stripes(self):
+        source = Image.new("RGB", (200, 400), (245, 245, 245))
+        draw = ImageDraw.Draw(source)
+        draw.rectangle((60, 40, 139, 359), fill=(128, 128, 128))
+        colors = {"head": (255, 0, 0), "chest": (0, 255, 0),
+                  "thigh": (0, 0, 255), "feet": (255, 0, 255)}
+        for name, top, bottom in (("head", 40, 71), ("chest", 128, 143),
+                                  ("thigh", 210, 225), ("feet", 335, 359)):
+            draw.rectangle((60, top, 139, bottom), fill=colors[name])
+        original = source.tobytes()
+        expected = {"cowboy_front": {"head", "chest", "thigh"},
+                    "cowboy_back": {"head", "chest", "thigh"},
+                    "upper_front": {"head", "chest"}, "face_front": {"head"}}
+        for key, included in expected.items():
+            with self.subTest(key=key):
+                cropped = conditioning_reference(source, key, 256, 256)
+                self.assertEqual(cropped.mode, "RGB")
+                self.assertEqual(cropped.size, (256, 256))
+                palette = {color for count, color in cropped.getcolors(256 * 256)}
+                for name, color in colors.items():
+                    self.assertEqual(color in palette, name in included,
+                                     f"Unexpected {name} stripe content in {key}")
+        self.assertEqual(source.tobytes(), original)
+        self.assertEqual(source.size, (200, 400))
+
+    def test_close_view_letterboxing_preserves_shape_without_stretching(self):
+        source = Image.new("RGB", (200, 400), "white")
+        draw = ImageDraw.Draw(source)
+        draw.rectangle((80, 60, 119, 359), fill=(160, 160, 160))
+        draw.rectangle((90, 40, 109, 59), fill="black")
+        cropped = conditioning_reference(source, "face_front", 200, 100)
+        dark = cropped.convert("L").point(lambda value: 255 if value < 20 else 0)
+        left, top, right, bottom = dark.getbbox()
+        self.assertLessEqual(abs((right - left) - (bottom - top)), 1,
+                             "A square marker must remain square after fitting")
+        self.assertEqual(cropped.size, (200, 100))
+        self.assertEqual(cropped.getpixel((0, 50)), (255, 255, 255))
+        self.assertGreater(top, 0, "The top of the head should retain a safe margin")
+
+    def test_other_views_keep_the_original_reference_object(self):
+        for key in ("full_front", "full_left", "full_right", "full_back",
+                    "knees_front", "knees_back", "prone_back"):
+            with self.subTest(key=key):
+                self.assertIs(conditioning_reference(self.reference, key, 512, 768), self.reference)
+
+    def test_white_or_transparent_reference_can_be_cropped(self):
+        source = Image.new("RGBA", (40, 80), (0, 0, 0, 0))
+        cropped = conditioning_reference(source, "face_front", 120, 100)
+        self.assertEqual(cropped.size, (120, 100))
+        self.assertEqual(cropped.getextrema(), ((255, 255), (255, 255), (255, 255)))
+        composite = rgb_on_white(source)
+        self.assertEqual(composite.mode, "RGB")
+        self.assertEqual(source.mode, "RGBA")
+
+    def test_reference_alpha_is_composited_on_white_and_downsized(self):
+        source = Image.new("RGBA", (400, 200), (255, 0, 0, 128))
+        prepared = prepare_reference(source, 100)
+        self.assertEqual(prepared.mode, "RGB")
+        self.assertEqual(prepared.size, (100, 50))
+        self.assertEqual(prepared.getpixel((50, 25)), (255, 127, 127))
+        self.assertEqual(source.mode, "RGBA")
+        self.assertEqual(source.size, (400, 200))
+        transparent = prepare_reference(Image.new("RGBA", (2, 2), (0, 0, 0, 0)), 100)
+        self.assertEqual(transparent.getpixel((0, 0)), (255, 255, 255))
+        self.assertEqual(transparent.size, (2, 2), "Small input should not be enlarged")
+
+    def test_reference_exif_orientation_is_applied(self):
+        source = Image.new("RGB", (40, 20), "red")
+        source.getexif()[274] = 6
+        prepared = prepare_reference(source, 100)
+        self.assertEqual(prepared.size, (20, 40))
+        self.assertNotIn(274, prepared.getexif())
+
+
+if __name__ == "__main__":
+    unittest.main()

views.py

@@ -1,447 +1,93 @@
-"""視点カタログ.
+"""Eleven views; no taggers or training-caption generation."""
+from dataclasses import dataclass
 
-視点を 1 行のレコードとして定義し、UI のチェックボックス・ZeroGPU の duration 見積り・
-キャプションへの確定タグ注入を **すべてこのテーブルから導出** する。
-視点を増やすときは VIEWS に行を足すだけでよい。
-
-カメラ指定は fal/Qwen-Image-Edit-2511-Multiple-Angles-LoRA のトリガ語彙に従う:
-    <sks> {azimuth} {elevation} {distance}
-LoRA は 4 仰角 × 8 方位 × 3 距離 = 96 カメラ位置で学習されているため、
-下の定数以外の文字列を入れても効かない。
-"""
-
-from dataclasses import dataclass, field
-from typing import Dict, List, Tuple
-
-# --- 角度 LoRA の語彙 (この 3 つの辞書の値以外は使わないこと) ---------------
-
-AZIMUTH = {
-    0: "front view",
-    45: "front-right quarter view",
-    90: "right side view",
-    135: "back-right quarter view",
-    180: "back view",
-    225: "back-left quarter view",
-    270: "left side view",
-    315: "front-left quarter view",
-}
-ELEVATION = {
-    -30: "low-angle shot",
-    0: "eye-level shot",
-    30: "elevated shot",
-    60: "high-angle shot",
-}
-DISTANCE = {
-    0.6: "close-up",
-    1.0: "medium shot",
-    1.8: "wide shot",
-}
-
-TRIGGER = "<sks>"
-
-# 全視点に共通で入れる背景指定。背景をプロンプトで固定しつつ、キャプション側にも
-# white background / simple background を明示的に入れることで、LoRA に背景が
-# 「無名の前提」として焼き付くのを避ける (タグとして学習させて後で外せるようにする)。
-BACKGROUND_PROMPT = "The background is plain white."
-GLOBAL_TAGS = ("solo", "simple background", "white background")
-
-# 学習バケット (kohya-ss 標準、いずれも約 1MP)
-PORTRAIT = (832, 1216)
-SQUARE = (1024, 1024)
-LANDSCAPE = (1216, 832)
-
-
-@dataclass(frozen=True)
-class Camera:
-    azimuth: int
-    elevation: int
-    distance: float
-
-    def phrase(self) -> str:
-        return f"{TRIGGER} {AZIMUTH[self.azimuth]} {ELEVATION[self.elevation]} {DISTANCE[self.distance]}"
-
-
-@dataclass(frozen=True)
-class Anchor:
-    """ポーズの基準画像。ここから各視点をカメラ移動で派生させる。"""
-
-    key: str
-    label_ja: str
-    pose_prompt: str
-    camera: Camera
-    size: Tuple[int, int]
-    # 条件付けに使う画像。"reference" はユーザーのアップロード画像、
-    # それ以外は別アンカーの key を指す。
-    source: str
+PROMPT_VERSION = "pose-transfer-v2"
 
 
 @dataclass(frozen=True)
 class View:
     key: str
-    label_ja: str
-    group_ja: str
-    anchor: str
-    camera: Camera
-    size: Tuple[int, int]
-    #: フレーミングなど、カメラ語彙では表せない指示
-    extra_prompt: str = ""
-    #: キャプションに必ず入れる Danbooru 系タグ。タガーは構図を当てにいけないため、
-    #: 既知のカメラパラメータから決定的に注入する。
-    tags: Tuple[str, ...] = field(default_factory=tuple)
-    #: 全身のポーズ説明を入れるか。実機検証の結果、寄り (close-up / medium) の視点に
-    #: 「両腕を腿の脇に下ろし、脚は左右対称に…」といった全身の描写を混ぜると、
-    #: モデルが全身を収めようとして寄りが効かなくなる。寄り視点では False にする。
-    use_pose_prompt: bool = True
-    #: 寄り視点で使う切り出し種別 ("face" / "upper" / "cowboy")。空なら切り出さない。
-    #: framing.CROP_FRACTION のキーに対応する。
-    crop_kind: str = ""
-    #: 切り出し元。空ならアンカー画像、それ以外は別の視点 key。
-    #: 例: 背面のカウボーイショットは背面の全身画像から切り出す必要がある。
-    crop_from: str = ""
-
-
-# --- ポーズアンカー ---------------------------------------------------------
-
-POSE_STANDING = (
-    "The character stands upright in a neutral A-pose, with both arms extended slightly "
-    "downward and close to the thighs, keeping the body evenly balanced on both sides. "
-    "The legs are positioned symmetrically with a narrow stance."
-)
-POSE_HUG_KNEES = (
-    "The character sits on the ground hugging both knees against the chest, with the arms "
-    "wrapped around the shins and the back slightly rounded. The feet are flat on the ground."
-)
-POSE_PRONE = (
-    "The character lies prone on the ground, face down on their stomach, with the legs "
-    "extended straight behind and the arms resting near the head."
-)
-
-# 寄り視点の指示文。実機検証で有効だった言い回しを採用している。
-# 「何が見えるか」だけでなく「何がフレーム外か」を明示すると効きがよい。
-FACE_TEXT = "A close-up portrait showing only the character's head and face."
-UPPER_TEXT = (
-    "An upper body shot. Only the head, shoulders and chest are visible; "
-    "the waist and legs are out of frame."
+    label: str
+    camera: str
+    pose: str
+    frame: str
+    shape: str = "portrait"
+
+
+STAND = "Stand upright in a neutral relaxed A-pose, arms lowered, legs narrowly spaced."
+SIT = "Sit on the ground hugging both knees against the chest, arms around the shins, feet on the floor."
+PRONE = "Lie face down on the stomach, legs straight, arms bent resting near the head."
+FULL = "Show the entire body including the top of the head and both feet."
+COWBOY = "Frame from the top of the head to mid-thigh; the knees and feet are outside the frame."
+
+VIEWS = (
+    View("full_front", "全身 正面", "front view, eye-level shot", STAND, FULL),
+    View("full_left", "全身 左側面", "left side view, eye-level shot", STAND, FULL),
+    View("full_right", "全身 右側面", "right side view, eye-level shot", STAND, FULL),
+    View("full_back", "全身 背面", "back view, eye-level shot", STAND, FULL),
+    View("cowboy_front", "腿上 正面", "front view, eye-level shot", "", COWBOY, "square"),
+    View("cowboy_back", "腿上 背面", "back view, eye-level shot", "", COWBOY, "square"),
+    View("upper_front", "上半身 正面", "front view, eye-level shot", "",
+         "Show only the head, shoulders and chest; waist and legs are outside the frame.", "square"),
+    View("face_front", "顔 正面", "front view, eye-level shot", "",
+         "Close-up portrait showing the head and face, with only the top of the shoulders visible.", "square"),
+    View("knees_front", "膝抱え 正面", "front view, eye-level shot", SIT, FULL),
+    View("knees_back", "膝抱え 背面", "back view, eye-level shot", SIT, FULL),
+    View("prone_back", "うつ伏せ 後方・俯瞰", "back view, high-angle shot", PRONE, FULL, "landscape"),
 )
-COWBOY_TEXT = (
-    "The character is framed from the mid-thigh up; "
-    "the feet and lower legs are out of frame."
-)
-
-ANCHORS: Dict[str, Anchor] = {
-    "standing": Anchor(
-        key="standing",
-        label_ja="立ち (基準)",
-        pose_prompt=POSE_STANDING,
-        camera=Camera(0, 0, 1.8),
-        size=PORTRAIT,
-        source="reference",
-    ),
-    "hug_knees": Anchor(
-        key="hug_knees",
-        label_ja="膝抱え座り (基準)",
-        pose_prompt=POSE_HUG_KNEES,
-        camera=Camera(0, 0, 1.8),
-        size=PORTRAIT,
-        source="standing",
-    ),
-    # うつ伏せは Tier1 では「後方・高所から」の 1 視点しか使わないため、アンカー自身を
-    # その構図で作って生成 1 回ぶんを節約する。ポーズ変更とカメラ移動を同時に要求する
-    # ぶん破綻しやすいので、app.py の詳細設定で 2 段階生成に切り替えられるようにしてある。
-    "prone": Anchor(
-        key="prone",
-        label_ja="うつ伏せ (基準)",
-        pose_prompt=POSE_PRONE,
-        camera=Camera(180, 60, 1.8),
-        size=LANDSCAPE,
-        source="standing",
-    ),
+BY_KEY = {view.key: view for view in VIEWS}
+DEFAULT_KEYS = list(BY_KEY)
+SIZES = {
+    "fast": {"portrait": (512, 768), "square": (640, 640), "landscape": (768, 512)},
+    "standard": {"portrait": (832, 1216), "square": (1024, 1024), "landscape": (1216, 832)},
 }
-
-#: 詳細設定で「うつ伏せを2段階生成」を選んだときに使うアンカーのカメラ。
-#: いったん正面やや俯瞰でポーズだけ作り、そのあとカメラを後方・高所へ動かす。
-PRONE_TWO_STAGE_CAMERA = Camera(0, 30, 1.8)
-
-
-# --- 視点カタログ (Tier1: ご指定の 11 視点) ---------------------------------
-
-VIEWS: List[View] = [
-    View(
-        key="full_front",
-        label_ja="全身 正面",
-        group_ja="全身 (三面図)",
-        anchor="standing",
-        camera=Camera(0, 0, 1.8),
-        size=PORTRAIT,
-        tags=("full body", "standing", "looking at viewer"),
-    ),
-    View(
-        key="full_left",
-        label_ja="全身 左側面",
-        group_ja="全身 (三面図)",
-        anchor="standing",
-        camera=Camera(270, 0, 1.8),
-        size=PORTRAIT,
-        tags=("full body", "standing", "from side", "profile"),
-    ),
-    View(
-        key="full_right",
-        label_ja="全身 右側面",
-        group_ja="全身 (三面図)",
-        anchor="standing",
-        camera=Camera(90, 0, 1.8),
-        size=PORTRAIT,
-        tags=("full body", "standing", "from side", "profile"),
-    ),
-    View(
-        key="full_back",
-        label_ja="全身 背面",
-        group_ja="全身 (三面図)",
-        anchor="standing",
-        camera=Camera(180, 0, 1.8),
-        size=PORTRAIT,
-        tags=("full body", "standing", "from behind"),
-    ),
-    View(
-        key="cowboy_front",
-        label_ja="カウボーイショット 正面",
-        group_ja="カウボーイショット",
-        anchor="standing",
-        camera=Camera(0, 0, 1.0),
-        size=SQUARE,
-        extra_prompt=COWBOY_TEXT,
-        tags=("cowboy shot", "standing", "looking at viewer"),
-        use_pose_prompt=False,
-        crop_kind="cowboy",
-        crop_from="full_front",
-    ),
-    View(
-        key="cowboy_back",
-        label_ja="カウボーイショット 背面",
-        group_ja="カウボーイショット",
-        anchor="standing",
-        camera=Camera(180, 0, 1.0),
-        size=SQUARE,
-        extra_prompt=COWBOY_TEXT,
-        tags=("cowboy shot", "standing", "from behind"),
-        use_pose_prompt=False,
-        crop_kind="cowboy",
-        # 背面の寄りは背面の全身画像から切り出す必要がある
-        crop_from="full_back",
-    ),
-    View(
-        key="upper_front",
-        label_ja="上半身 正面",
-        group_ja="寄り",
-        anchor="standing",
-        camera=Camera(0, 0, 0.6),
-        size=SQUARE,
-        extra_prompt=UPPER_TEXT,
-        tags=("upper body", "looking at viewer"),
-        use_pose_prompt=False,
-        crop_kind="upper",
-        crop_from="full_front",
-    ),
-    View(
-        key="face_front",
-        label_ja="顔 正面",
-        group_ja="寄り",
-        anchor="standing",
-        camera=Camera(0, 0, 0.6),
-        size=SQUARE,
-        extra_prompt=FACE_TEXT,
-        tags=("portrait", "close-up", "looking at viewer"),
-        use_pose_prompt=False,
-        crop_kind="face",
-        crop_from="full_front",
-    ),
-    View(
-        key="knees_front",
-        label_ja="膝抱え 正面",
-        group_ja="膝抱え座り",
-        anchor="hug_knees",
-        camera=Camera(0, 0, 1.8),
-        size=PORTRAIT,
-        tags=("full body", "sitting", "hugging own legs", "knees up"),
-    ),
-    View(
-        key="knees_back",
-        label_ja="膝抱え 背面",
-        group_ja="膝抱え座り",
-        anchor="hug_knees",
-        camera=Camera(180, 0, 1.8),
-        size=PORTRAIT,
-        tags=("full body", "sitting", "hugging own legs", "knees up", "from behind"),
-    ),
-    View(
-        key="prone_back",
-        label_ja="うつ伏せ 後方から",
-        group_ja="うつ伏せ",
-        anchor="prone",
-        camera=Camera(180, 60, 1.8),
-        size=LANDSCAPE,
-        tags=("full body", "lying", "on stomach", "from behind", "from above"),
-    ),
-]
-
-VIEW_BY_KEY: Dict[str, View] = {v.key: v for v in VIEWS}
-DEFAULT_SELECTION: List[str] = [v.key for v in VIEWS]
-
-#: UI のグループ見出し順 (VIEWS の出現順を保つ)
-GROUP_ORDER: List[str] = list(dict.fromkeys(v.group_ja for v in VIEWS))
-
-PRESETS: Dict[str, List[str]] = {
-    "全選択 (11視点)": [v.key for v in VIEWS],
-    "三面図のみ (4視点)": ["full_front", "full_left", "full_right", "full_back"],
-    "最小構成 (2視点)": ["full_front", "face_front"],
-}
-
-
-# --- プロンプト組み立て -----------------------------------------------------
-
-
-def _compose(camera: Camera, pose_prompt: str, extra_prompt: str, user_extra: str) -> str:
-    parts = [camera.phrase(), pose_prompt]
-    if extra_prompt:
-        parts.append(extra_prompt)
-    parts.append(BACKGROUND_PROMPT)
-    user_extra = (user_extra or "").strip()
-    if user_extra:
-        parts.append(user_extra)
-    return " ".join(p.strip() for p in parts if p and p.strip())
-
-
-def anchor_prompt(anchor: Anchor, user_extra: str = "", camera: Camera = None) -> str:
-    return _compose(camera or anchor.camera, anchor.pose_prompt, "", user_extra)
-
-
-def view_prompt(view: View, user_extra: str = "") -> str:
-    pose = ANCHORS[view.anchor].pose_prompt if view.use_pose_prompt else ""
-    return _compose(view.camera, pose, view.extra_prompt, user_extra)
-
-
-def caption_tags(view: View) -> Tuple[str, ...]:
-    """タガー出力とマージする前の、構図に由来する確定タグ。"""
-    return tuple(GLOBAL_TAGS) + view.tags
-
-
-# --- 依存解決 / 生成計画 ----------------------------------------------------
-
-
-@dataclass(frozen=True)
-class Step:
-    """1 回の pipe() 呼び出し。"""
-
-    key: str  #: 生成物の識別子 (視点 key か "anchor:<name>")
-    kind: str  #: "anchor" | "view"
-    label_ja: str
-    prompt_of: object  #: Anchor または View
-    source: str  #: 条件付け画像の識別子 ("reference" | "anchor:<name>" | 視点 key)
-    size: Tuple[int, int]
-    view_key: str = ""  #: このステップが直接生み出す視点 (あれば)
-    crop_kind: str = ""  #: 条件付け画像を切り出す種別 (framing.CROP_FRACTION のキー)
-    #: ユーザーが選んだ視点ではなく、寄りの切り出し元として必要になっただけの中間生成か
-    intermediate: bool = False
-
-
-def _anchor_id(key: str) -> str:
-    return f"anchor:{key}"
-
-
-def build_plan(selected_keys: List[str], two_stage_prone: bool = False) -> List[Step]:
-    """選択された視点を生成するために必要な pipe() 呼び出しを、依存順に並べて返す。
-
-    依存は 2 種類ある:
-      - ポーズアンカー (立ち → 膝抱え / うつ伏せ)
-      - 寄りの切り出し元となる別の視点 (背面カウボーイ ← 背面全身)
-    アンカーのカメラと一致し追加指示のない視点は、アンカー生成で兼ねて 1 回省く。
-    """
-    requested = [k for k in selected_keys if k in VIEW_BY_KEY]
-    if not requested:
-        return []
-
-    # --- 1. 必要な視点の閉包を取る (寄りの切り出し元をたどる) ---
-    needed_views: List[str] = []
-
-    def require_view(key: str) -> None:
-        if key in needed_views:
-            return
-        view = VIEW_BY_KEY[key]
-        if view.crop_from:
-            require_view(view.crop_from)
-        needed_views.append(key)
-
-    for k in requested:
-        require_view(k)
-
-    # --- 2. 必要なアンカーの閉包を取る ---
-    anchors_needed: List[str] = []
-
-    def require_anchor(name: str) -> None:
-        if name in anchors_needed:
-            return
-        src = ANCHORS[name].source
-        if src != "reference":
-            require_anchor(src)
-        anchors_needed.append(name)
-
-    for k in needed_views:
-        require_anchor(VIEW_BY_KEY[k].anchor)
-
-    # --- 3. アンカーを依存順に並べる ---
-    steps: List[Step] = []
-    anchor_serves: Dict[str, str] = {}
-
-    for name in anchors_needed:
-        base = ANCHORS[name]
-        camera = PRONE_TWO_STAGE_CAMERA if (name == "prone" and two_stage_prone) else base.camera
-        anchor = Anchor(
-            key=base.key,
-            label_ja=base.label_ja,
-            pose_prompt=base.pose_prompt,
-            camera=camera,
-            size=base.size,
-            source=base.source,
+SIZES["balanced"] = SIZES["standard"]
+REFERENCE_RESOLUTION = {"fast": 640, "balanced": 640, "standard": 1024}
+
+
+def validate_keys(keys):
+    if not keys:
+        raise ValueError("視点を1つ以上選択してください。")
+    if any(key not in BY_KEY for key in keys):
+        raise ValueError("不明な視点が含まれています。")
+    return list(dict.fromkeys(keys))
+
+
+def make_prompt(view, extra="", pose_guide=True, angles=False):
+    parts = []
+    if angles:
+        # Qwen 2.1 adapter grammar; the 2511 <sks> grammar is NOT used.
+        parts.append("<mva> " + view.camera + (" close-up" if view.key in ("face_front", "upper_front") else ""))
+    if pose_guide:
+        parts.append(
+            "Edit Image 2: replace its grey mannequin with the character from Image 1. "
+            "Keep Image 2's pose, body orientation, camera, crop and placement in the frame. "
+            "Image 1 supplies only the character design, outfit, hair and rendering style; "
+            "do not preserve Image 1's pose, camera direction or framing. "
+            "Render the character's normal skin and clothing, with no mannequin joints or grey material."
         )
-        served = ""
-        for k in needed_views:
-            v = VIEW_BY_KEY[k]
-            if v.anchor == name and v.camera == camera and not v.extra_prompt:
-                served = v.key
-                break
-        if served:
-            anchor_serves[name] = served
-        steps.append(
-            Step(
-                key=_anchor_id(name),
-                kind="anchor",
-                label_ja=base.label_ja,
-                prompt_of=anchor,
-                source="reference" if base.source == "reference" else _anchor_id(base.source),
-                size=VIEW_BY_KEY[served].size if served else anchor.size,
-                view_key=served,
-                intermediate=bool(served) and served not in requested,
-            )
+    else:
+        parts.append("Reshoot the character in Image 1 from the requested camera and framing.")
+    if view.key in ("full_back", "cowboy_back", "knees_back"):
+        parts.append(
+            "Strict rear view. The character faces away from the viewer. "
+            "Show the back of the head, back of the hair and back of the clothing. "
+            "The face, eyes and front of the chest are hidden."
         )
-
-    # --- 4. 視点を依存順に並べる (needed_views は既に依存順) ---
-    for k in needed_views:
-        v = VIEW_BY_KEY[k]
-        if anchor_serves.get(v.anchor) == v.key:
-            continue  # アンカー生成で兼ねた
-        source = v.crop_from if v.crop_from else _anchor_id(v.anchor)
-        steps.append(
-            Step(
-                key=v.key,
-                kind="view",
-                label_ja=v.label_ja,
-                prompt_of=v,
-                source=source,
-                size=v.size,
-                view_key=v.key,
-                crop_kind=v.crop_kind,
-                intermediate=k not in requested,
-            )
+    elif view.key == "full_left":
+        parts.append("Strict profile, with the nose pointing to the RIGHT edge of the image.")
+    elif view.key == "full_right":
+        parts.append("Strict profile, with the nose pointing to the LEFT edge of the image.")
+    elif view.key == "prone_back":
+        parts.append(
+            "Look down at the character's back while they lie face down on the floor. "
+            "Their chest and face point toward the floor, not toward the camera. "
+            "Place the head at the RIGHT of the image and feet at the LEFT, matching Image 2."
+            if pose_guide else
+            "Look down at the character's back while they lie face down on the floor. "
+            "Their chest and face point toward the floor, not toward the camera."
         )
-
-    return steps
+    parts.extend(["Camera: " + view.camera + ".", view.pose, view.frame,
+                  "Preserve the identity, hair, outfit details, colors and visual style from Image 1. "
+                  "Use a plain white background. One character, no text, no collage.", extra.strip()])
+    return " ".join(part for part in parts if part)