Upload 194 files

.gitattributes

@@ -33,3 +33,17 @@ 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
+face_parsing-main/1.docx filter=lfs diff=lfs merge=lfs -text
+face_parsing-main/samples/sample.gif filter=lfs diff=lfs merge=lfs -text
+flask_GAN/result/vis/tmp.png filter=lfs diff=lfs merge=lfs -text
+flask_GAN/runtime/outputs/in_3f084cf9775a45d9b21c686ae18ecdf0.png filter=lfs diff=lfs merge=lfs -text
+flask_GAN/runtime/outputs/in_986cd78ee11a4f1fa99385e0efac4563.png filter=lfs diff=lfs merge=lfs -text
+flask_GAN/runtime/outputs/in_c04f130d833c47559f3c1e76c95f8a55.png filter=lfs diff=lfs merge=lfs -text
+flask_GAN/runtime/outputs/in_c6f89cfcf3f047999eb74eb4804f3be9.png filter=lfs diff=lfs merge=lfs -text
+flask_GAN/runtime/outputs/in_f77c29d6f9174b54b5678d30d4834fbf.png filter=lfs diff=lfs merge=lfs -text
+flask_GAN/runtime/outputs/out_085f535a5a4a4e8f80f38ac6125cc7ff.png filter=lfs diff=lfs merge=lfs -text
+flask_GAN/runtime/outputs/out_3a41682e7cb74fe2abaa51f5754dd5c1.png filter=lfs diff=lfs merge=lfs -text
+flask_GAN/runtime/outputs/out_b7239cb192984fd781750350c16b9d0d.png filter=lfs diff=lfs merge=lfs -text
+flask_GAN/runtime/outputs/out_ebdffbbdd31b4516b8241f9907be8f15.png filter=lfs diff=lfs merge=lfs -text
+flask_GAN/runtime/outputs/out_f73c6c5c48f84ece9fa6b28b2c180af7.png filter=lfs diff=lfs merge=lfs -text
+pix2pix_vgg/imgs/horse2zebra.gif filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,16 @@
+FROM python:3.9
+
+# 设置工作目录
+WORKDIR /code
+
+# 拷贝所有项目文件
+COPY . /code
+
+# 安装依赖
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Hugging Face 会注入 PORT，我们设置默认值
+ENV PORT=7860
+
+# 启动你的 Flask 应用
+CMD ["python", "flask_GAN/app_auto_mask.py"]

face_parsing-main/.gitignore

@@ -0,0 +1,162 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

face_parsing-main/1.docx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b3956a0b58d8c649aab1a66396bff72b4cf8a746e46c8d421e6175303d602de5
+size 1141639

face_parsing-main/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 XIAN-HHappy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

face_parsing-main/README.md

@@ -0,0 +1,47 @@
+# face parsing
+人脸区域分割
+
+## 项目介绍    
+注意：该项目不包括人脸检测部分，人脸检测项目地址：https://github.com/XIAN-HHappy/yolo_v3
+
+* 图片示例：  
+![image](samples/t.jpg)    
+
+* 视频示例：  
+![video](samples/sample.gif)    
+
+## 项目配置  
+* 作者开发环境：  
+* Python 3.7  
+* PyTorch >= 1.5.1  
+
+## 数据集  
+* CelebAMask-HQ dataset，数据下载地址：  
+  https://github.com/switchablenorms/CelebAMask-HQ
+
+```
+• The CelebAMask-HQ dataset is available for non-commercial research purposes only.
+• You agree not to reproduce, duplicate, copy, sell, trade, resell or exploit for any commercial purposes, any portion of the images and any portion of derived data.
+• You agree not to further copy, publish or distribute any portion of the CelebAMask-HQ dataset. Except, for internal use at a single site within the same organization it is allowed to make copies of the dataset.
+
+```
+
+* 数据集制作  
+  下载数据集并解压，然后运行脚本 prepropess_data.py,生成训练用的mask，注意脚本内相关参数配置。  
+
+## 预训练模型   
+  提供512,256两种分辨率的预训练模型。    
+* [预训练模型下载地址(百度网盘 Password: ri6m )](https://pan.baidu.com/s/1I5fPAyXDfIh9M5POs80ovg)     
+
+## 项目使用方法   
+
+### 步骤1：生成训练数据
+* 目前建议输出2种样本分辨率 512 和 256 （提供512,256两种分辨率的预训练模型），分辨率太小返回原图尺寸时会出现掩码锯齿状，需要后处理解决。    
+  注意训练、推理脚本也要做相应的分辨率对应设置。    
+* 运行脚本：prepropess_data.py (注意脚本内相关参数配置 )   
+
+### 步骤2：模型训练     
+* 根目录下运行命令： python train.py     (注意脚本内相关参数配置 )   
+
+### 步骤3：模型推理    
+* 根目录下运行命令： python inference.py   (注意脚本内相关参数配置  )  

face_parsing-main/crop_b_512_keepname.py

@@ -0,0 +1,58 @@
+import os
+from PIL import Image
+import argparse
+
+def is_img(p):
+    return os.path.splitext(p)[1].lower() in {".jpg", ".jpeg", ".png", ".bmp", ".tif", ".tiff", ".webp"}
+
+def main(in_dir, out_dir, y_top=400, patch=512, strict_w=1024, min_h=None):
+    os.makedirs(out_dir, exist_ok=True)
+    if min_h is None:
+        min_h = y_top + patch  # 默认至少要容纳裁剪高度
+
+    files = [f for f in os.listdir(in_dir) if is_img(f)]
+    if not files:
+        print(f"[WARN] 没在 {in_dir} 里找到图像文件")
+        return
+
+    kept, skipped = 0, 0
+    for fn in sorted(files):
+        ip = os.path.join(in_dir, fn)
+        try:
+            im = Image.open(ip).convert("RGB")
+        except Exception as e:
+            print(f"[SKIP] 打不开：{ip} ({e})")
+            skipped += 1
+            continue
+
+        w, h = im.size
+        # 期望 A|B 横向拼接（每半边 512 宽）：总宽至少 1024，高度至少 y_top+patch
+        if w < strict_w or h < min_h:
+            print(f"[SKIP] 尺寸不符：{fn} size={w}x{h}，需要 >= {strict_w}x{min_h}")
+            skipped += 1
+            continue
+
+        # 右半边 B（假定 AB 横拼）：[w//2, 0, w, h]，应为 512x1536
+        x0 = w // 2
+        b = im.crop((x0, 0, w, h))
+
+        # 从 y_top 处裁 512x512
+        y0, y1 = y_top, y_top + patch
+        b512 = b.crop((0, y0, patch, y1))  # (left, top, right, bottom)
+
+        # 输出到 out_dir，文件名与原图一致（不加后缀）
+        op = os.path.join(out_dir, fn)
+        b512.save(op)
+        kept += 1
+        print(f"[OK] {fn} -> {op}")
+
+    print(f"\n完成：保存 {kept} 张，跳过 {skipped} 张。输出目录：{out_dir}")
+
+if __name__ == "__main__":
+    ap = argparse.ArgumentParser(description="从 A|B 拼接图裁出右半 B 的 512x512，小图文件名保持不变")
+    ap.add_argument("--in_dir",  required=True, help="输入目录（含 1024x1536 的 A|B 拼图）")
+    ap.add_argument("--out_dir", required=True, help="输出目录（文件名与输入相同）")
+    ap.add_argument("--y_top",   type=int, default=400, help="裁剪起始 y（默认 400）")
+    ap.add_argument("--patch",   type=int, default=512, help="裁剪边长（默认 512）")
+    args = ap.parse_args()
+    main(args.in_dir, args.out_dir, args.y_top, args.patch)

face_parsing-main/expand_mask.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+将鼻子 mask 向上和向右扩展为矩形区域。
+适合 Pix2Pix 测试或 inpainting 掩膜增强使用。
+"""
+
+import cv2
+import numpy as np
+from pathlib import Path
+
+def expand_mask_up_right(mask: np.ndarray, top_pad=30, right_pad=150):
+    """
+    向上 (top_pad) 和向右 (right_pad) 扩充白色区域成矩形。
+    参数:
+        mask: 灰度 mask (0/255)
+        top_pad: 向上扩展像素（少量，例如 20-50）
+        right_pad: 向右扩展像素（较多，例如 100-200）
+    返回:
+        新的扩充 mask (uint8)
+    """
+    ys, xs = np.where(mask > 0)
+    if len(ys) == 0:
+        return mask
+
+    top, bottom = ys.min(), ys.max()
+    left, right = xs.min(), xs.max()
+    H, W = mask.shape
+
+    new_top = max(0, top - top_pad)
+    new_bottom = min(H, bottom)
+    new_right = min(W, right + right_pad)
+
+    new_mask = np.zeros_like(mask)
+    new_mask[new_top:new_bottom, left:new_right] = 255
+    return new_mask
+
+def batch_process(in_dir="./result_test", out_dir="./result_expanded", top_pad=30, right_pad=150):
+    in_dir = Path(in_dir)
+    out_dir = Path(out_dir)
+    out_dir.mkdir(exist_ok=True)
+
+    for p in in_dir.glob("*.png"):
+        mask = cv2.imread(str(p), cv2.IMREAD_GRAYSCALE)
+        new_mask = expand_mask_up_right(mask, top_pad=top_pad, right_pad=right_pad)
+        out_path = out_dir / p.name
+        cv2.imwrite(str(out_path), new_mask)
+        print(f"[OK] saved: {out_path}")
+
+if __name__ == "__main__":
+    # 按实际情况调整扩展范围
+    batch_process(in_dir="./result_test", out_dir="./result_expanded", top_pad=30, right_pad=30)

face_parsing-main/expand_masks_512_to_1536.py

@@ -0,0 +1,37 @@
+# expand_masks_512_to_1536.py
+# 把 512x512 的鼻子二值掩码，贴回到 1536x512（竖向位置 y=[y_top, y_top+512)），文件名不变
+import os
+import argparse
+from PIL import Image
+import numpy as np
+
+def is_img(p): return os.path.splitext(p)[1].lower() in {".png", ".jpg", ".jpeg", ".bmp"}
+
+def expand_dir(in_dir, out_dir, y_top=400, H=1536, W=512):
+    os.makedirs(out_dir, exist_ok=True)
+    n = 0
+    for fn in sorted(os.listdir(in_dir)):
+        if not is_img(fn): 
+            continue
+        m = Image.open(os.path.join(in_dir, fn)).convert("L")   # 读灰度
+        m = np.array(m)
+        if m.shape != (512, 512):
+            raise ValueError(f"{fn} 不是 512x512，而是 {m.shape}")
+
+        m = (m > 127).astype(np.uint8)                          # 二值化到 {0,1}
+        big = np.zeros((H, W), dtype=np.uint8)                  # 1536x512 全黑
+        big[y_top:y_top+512, 0:512] = m                         # 贴回到指定位置
+
+        Image.fromarray(big * 255).save(
+            os.path.join(out_dir, os.path.splitext(fn)[0] + ".png")
+        )
+        n += 1
+    print(f"[DONE] {in_dir} -> {out_dir}  共 {n} 张，y_top={y_top}, 输出尺寸={H}x{W}")
+
+if __name__ == "__main__":
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--in_dir",  required=True, help="输入 512x512 鼻子 mask 目录（文件名与原图一致）")
+    ap.add_argument("--out_dir", required=True, help="输出 1536x512 掩码目录（文件名不变）")
+    ap.add_argument("--y_top",   type=int, default=400, help="竖向贴回起始 y，默认 400")
+    args = ap.parse_args()
+    expand_dir(args.in_dir, args.out_dir, y_top=args.y_top)

face_parsing-main/face_dataset.py

@@ -0,0 +1,60 @@
+#!/usr/bin/python
+# -*- encoding: utf-8 -*-
+
+import torch
+from torch.utils.data import Dataset
+import torchvision.transforms as transforms
+
+import os.path as osp
+import os
+from PIL import Image
+import numpy as np
+import json
+import cv2
+
+from transform import *
+
+
+
+class FaceMask(Dataset):
+    def __init__(self, rootpth,img_size, cropsize=(640, 480), mode='train', *args, **kwargs):
+        super(FaceMask, self).__init__(*args, **kwargs)
+        assert mode in ('train', 'val', 'test')
+        self.mode = mode
+        self.ignore_lb = 255
+        self.rootpth = rootpth
+        self.img_size = img_size
+
+        self.imgs = os.listdir(os.path.join(self.rootpth, 'CelebA-HQ-img'))
+
+        #  pre-processing
+        self.to_tensor = transforms.Compose([
+            transforms.ToTensor(),
+            transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),
+            ])
+        self.trans_train = Compose([
+            ColorJitter(
+                brightness=0.5,
+                contrast=0.5,
+                saturation=0.5),
+            HorizontalFlip(),
+            RandomScale((0.75, 1.0, 1.25, 1.5, 1.75, 2.0)),
+            RandomCrop(cropsize)
+            ])
+
+    def __getitem__(self, idx):
+        impth = self.imgs[idx]
+        img = Image.open(osp.join(self.rootpth, 'CelebA-HQ-img', impth))
+        img = img.resize((self.img_size,self.img_size), Image.BILINEAR)
+        label = Image.open(osp.join(self.rootpth, 'mask_{}'.format(self.img_size), impth[:-3]+'png')).convert('P')
+        # print(np.unique(np.array(label)))
+        if self.mode == 'train':
+            im_lb = dict(im=img, lb=label)
+            im_lb = self.trans_train(im_lb)
+            img, label = im_lb['im'], im_lb['lb']
+        img = self.to_tensor(img)
+        label = np.array(label).astype(np.int64)[np.newaxis, :]
+        return img, label
+
+    def __len__(self):
+        return len(self.imgs)

face_parsing-main/fp_512.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3c6f392bafa99c8b3fb3408a5f9d35d6623eb26893018ea7022625e8b0c76484
+size 53289081

face_parsing-main/inference.py

@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+import os, os.path as osp
+import argparse
+import numpy as np
+import torch
+import torchvision.transforms as T
+import cv2
+from PIL import Image
+
+# 你的工程里：from model import BiSeNet
+from model import BiSeNet
+
+
+# 颜色表（19 类；按你的仓库类别顺序）
+PART_COLORS = np.array([
+    [255,   0,   0], [255,  85,   0], [255, 170,   0],
+    [255,   0,  85], [255,   0, 170],
+    [  0, 255,   0], [ 85, 255,   0], [170, 255,   0],
+    [  0, 255,  85], [  0, 255, 170],
+    [  0,   0, 255], [ 85,   0, 255], [170,   0, 255],
+    [  0,  85, 255], [  0, 170, 255],
+    [255, 255,   0], [255, 255,  85], [255, 255, 170],
+    [255,   0, 255]
+], dtype=np.uint8)
+
+
+def is_img(p):
+    return osp.splitext(p)[1].lower() in {".jpg",".jpeg",".png",".bmp",".tif",".tiff",".webp"}
+
+
+def overlay_parsing(rgb, parsing, alpha=0.45):
+    """parsing: (H,W) int; rgb: (H,W,3) uint8 -> overlay (H,W,3) uint8"""
+    h, w = parsing.shape
+    color = PART_COLORS[np.clip(parsing, 0, len(PART_COLORS)-1)]
+    blend = (alpha*color + (1-alpha)*rgb).astype(np.uint8)
+    return blend
+
+
+def save_index_png(parsing, path):
+    """把类别 id 存成 ‘索引图’（单通道 PNG，便于后处理）"""
+    Image.fromarray(parsing.astype(np.uint8), mode='L').save(path)
+
+
+def main(args):
+    device = torch.device(args.device if torch.cuda.is_available() and args.device.startswith("cuda")
+                          else "cpu")
+    print(f"[INFO] device = {device}")
+
+    # 模型
+    n_classes = 19
+    net = BiSeNet(n_classes=n_classes).to(device)
+    print(f"[INFO] load weights: {args.weights}")
+    state = torch.load(args.weights, map_location=device)
+    net.load_state_dict(state, strict=True)
+    net.eval()
+
+    tfm = T.Compose([
+        T.ToTensor(),
+        T.Normalize((0.485,0.456,0.406), (0.229,0.224,0.225)),
+    ])
+
+    os.makedirs(args.save_vis, exist_ok=True)
+    if args.save_idx:
+        os.makedirs(args.save_idx, exist_ok=True)
+
+    names = [f for f in sorted(os.listdir(args.image_dir)) if is_img(f)]
+    if not names:
+        print(f"[WARN] no images in {args.image_dir}")
+        return
+
+    with torch.no_grad():
+        for i, fn in enumerate(names, 1):
+            ip = osp.join(args.image_dir, fn)
+            bgr = cv2.imread(ip, cv2.IMREAD_COLOR)
+            if bgr is None:
+                print(f"[SKIP] read fail: {ip}")
+                continue
+            rgb = cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB)
+
+            # 网络输入大小
+            pil = Image.fromarray(rgb).resize((args.img_size, args.img_size), Image.BILINEAR)
+            x = tfm(pil).unsqueeze(0).to(device)
+
+            out = net(x)
+            # 兼容返回 tuple/list 的实现
+            if isinstance(out, (list, tuple)):
+                out = out[0]
+            parsing_small = out.squeeze(0).argmax(0).detach().cpu().numpy().astype(np.uint8)
+            # 还原回原图大小
+            parsing = cv2.resize(parsing_small, (rgb.shape[1], rgb.shape[0]), interpolation=cv2.INTER_NEAREST)
+
+            # 保存可视化
+            vis = overlay_parsing(rgb, parsing, alpha=args.alpha)
+            vis_bgr = cv2.cvtColor(vis, cv2.COLOR_RGB2BGR)
+            cv2.imwrite(osp.join(args.save_vis, fn), vis_bgr)
+
+            # 可选：保存索引图（单通道 id）
+            if args.save_idx:
+                save_index_png(parsing, osp.join(args.save_idx, osp.splitext(fn)[0] + ".png"))
+
+            uniq = np.unique(parsing)
+            print(f"[{i:04d}/{len(names)}] {fn}  classes={uniq.tolist()}  -> vis:{args.save_vis}")
+
+    print("[DONE]")
+
+
+if __name__ == "__main__":
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--image_dir", type=str, default="./images", help="输入图片目录")
+    ap.add_argument("--weights",   type=str, default="./fp_512.pth", help="权重路径")
+    ap.add_argument("--img_size",  dest="img_size", type=int, default=512, help="推理分辨率(方形)")
+    ap.add_argument("--device",    type=str, default="cuda:0", help="'cuda:0' 或 'cpu'")
+    ap.add_argument("--save_vis",  type=str, default="./result/vis", help="彩色叠加图输出目录")
+    ap.add_argument("--save_idx",  type=str, default="./result/idx", help="可选：索引图输出目录(单通道PNG)，为空则不保存")
+    ap.add_argument("--alpha",     type=float, default=0.45, help="可视化叠加不透明度")
+    args = ap.parse_args()
+    # 若不想保存索引图，传空字符串即可
+    if args.save_idx == "":
+        args.save_idx = None
+    main(args)

face_parsing-main/loss.py

@@ -0,0 +1,75 @@
+#!/usr/bin/python
+# -*- encoding: utf-8 -*-
+
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+import numpy as np
+
+
+class OhemCELoss(nn.Module):
+    def __init__(self, thresh, n_min, ignore_lb=255, *args, **kwargs):
+        super(OhemCELoss, self).__init__()
+        self.thresh = -torch.log(torch.tensor(thresh, dtype=torch.float)).cuda()
+        self.n_min = n_min
+        self.ignore_lb = ignore_lb
+        self.criteria = nn.CrossEntropyLoss(ignore_index=ignore_lb, reduction='none')
+
+    def forward(self, logits, labels):
+        N, C, H, W = logits.size()
+        loss = self.criteria(logits, labels).view(-1)
+        loss, _ = torch.sort(loss, descending=True)
+        if loss[self.n_min] > self.thresh:
+            loss = loss[loss>self.thresh]
+        else:
+            loss = loss[:self.n_min]
+        return torch.mean(loss)
+
+
+class SoftmaxFocalLoss(nn.Module):
+    def __init__(self, gamma, ignore_lb=255, *args, **kwargs):
+        super(SoftmaxFocalLoss, self).__init__()
+        self.gamma = gamma
+        self.nll = nn.NLLLoss(ignore_index=ignore_lb)
+
+    def forward(self, logits, labels):
+        scores = F.softmax(logits, dim=1)
+        factor = torch.pow(1.-scores, self.gamma)
+        log_score = F.log_softmax(logits, dim=1)
+        log_score = factor * log_score
+        loss = self.nll(log_score, labels)
+        return loss
+
+
+if __name__ == '__main__':
+    torch.manual_seed(15)
+    criteria1 = OhemCELoss(thresh=0.7, n_min=16*20*20//16).cuda()
+    criteria2 = OhemCELoss(thresh=0.7, n_min=16*20*20//16).cuda()
+    net1 = nn.Sequential(
+        nn.Conv2d(3, 19, kernel_size=3, stride=2, padding=1),
+    )
+    net1.cuda()
+    net1.train()
+    net2 = nn.Sequential(
+        nn.Conv2d(3, 19, kernel_size=3, stride=2, padding=1),
+    )
+    net2.cuda()
+    net2.train()
+
+    with torch.no_grad():
+        inten = torch.randn(16, 3, 20, 20).cuda()
+        lbs = torch.randint(0, 19, [16, 20, 20]).cuda()
+        lbs[1, :, :] = 255
+
+    logits1 = net1(inten)
+    logits1 = F.interpolate(logits1, inten.size()[2:], mode='bilinear')
+    logits2 = net2(inten)
+    logits2 = F.interpolate(logits2, inten.size()[2:], mode='bilinear')
+
+    loss1 = criteria1(logits1, lbs)
+    loss2 = criteria2(logits2, lbs)
+    loss = loss1 + loss2
+    print(loss.detach().cpu())
+    loss.backward()

face_parsing-main/make_nose_masks.py

@@ -0,0 +1,79 @@
+# make_nose_masks.py
+import os
+import cv2
+import numpy as np
+import argparse
+
+def is_img(fn):
+    return os.path.splitext(fn)[1].lower() in {".png", ".jpg", ".jpeg", ".bmp", ".tif", ".tiff", ".webp"}
+
+def read_idx(path):
+    """兼容灰度/调色板/彩色三种读法，返回 uint8 的类别ID矩阵"""
+    arr = cv2.imread(path, cv2.IMREAD_UNCHANGED)
+    if arr is None:
+        raise RuntimeError(f"read fail: {path}")
+    # 如果是彩色(3通道)，通常三通道值一致；取任一通道即可
+    if arr.ndim == 3:
+        arr = arr[:, :, 0]
+    return arr.astype(np.uint8)
+
+def extract_nose(idx, nose_id=10):
+    """从 idx 中提取鼻子为 255, 其他为 0"""
+    return np.where(idx == nose_id, 255, 0).astype(np.uint8)
+
+def paste_to_canvas(mask_512, target_h=1536, target_w=512, y_top=400):
+    """把 512×512 的 mask 贴回 512×1536 的画布（竖向），默认贴在 [y_top:y_top+512]"""
+    h, w = mask_512.shape[:2]
+    if (h, w) != (512, 512):
+        raise ValueError(f"mask size must be 512x512, got {w}x{h}")
+    if y_top < 0 or y_top + 512 > target_h:
+        raise ValueError(f"y_top out of range: y_top={y_top}, target_h={target_h}")
+
+    canvas = np.zeros((target_h, target_w), dtype=np.uint8)
+    # 你的 512×512 小图本来就是整张的宽度，所以横向从 0 到 512 直接贴就可以
+    canvas[y_top:y_top + 512, 0:512] = mask_512
+    return canvas
+
+def main(args):
+    os.makedirs(args.out_dir, exist_ok=True)
+
+    files = [f for f in os.listdir(args.idx_dir) if is_img(f)]
+    if not files:
+        print(f"[WARN] 在 {args.idx_dir} 没有找到图片文件")
+        return
+
+    kept = 0
+    for i, fn in enumerate(sorted(files), 1):
+        in_path = os.path.join(args.idx_dir, fn)
+        try:
+            idx = read_idx(in_path)
+            nose_512 = extract_nose(idx, args.nose_id)
+            canvas = paste_to_canvas(
+                nose_512,
+                target_h=args.target_h,
+                target_w=args.target_w,
+                y_top=args.y_top,
+            )
+            out_path = os.path.join(args.out_dir, os.path.splitext(fn)[0] + ".png")
+            cv2.imwrite(out_path, canvas)
+            kept += 1
+            if args.verbose and (i % 10 == 1 or i == len(files)):
+                print(f"[{i:04d}/{len(files)}] {fn} -> {out_path}")
+        except Exception as e:
+            print(f"[SKIP] {fn}: {e}")
+
+    print(f"\n✅ 完成：保存 {kept} 张。输出目录：{args.out_dir}")
+
+if __name__ == "__main__":
+    p = argparse.ArgumentParser(
+        description="把 idx 标签图中的鼻子(默认id=10)抠出来，并贴回到 512x1536 的黑白 mask（文件名保持不变）"
+    )
+    p.add_argument("--idx_dir", required=True, help="idx 输入目录（每像素=类别ID，512x512）")
+    p.add_argument("--out_dir", required=True, help="输出目录（512x1536 黑白图）")
+    p.add_argument("--nose_id", type=int, default=10, help="鼻子类别ID（默认10）")
+    p.add_argument("--y_top", type=int, default=400, help="贴回时的起始高度（默认400）")
+    p.add_argument("--target_h", type=int, default=1536, help="目标高度（默认 1536）")
+    p.add_argument("--target_w", type=int, default=512, help="目标宽度（默认 512）")
+    p.add_argument("--verbose", action="store_true", help="打印处理进度")
+    args = p.parse_args()
+    main(args)

face_parsing-main/model.py

@@ -0,0 +1,283 @@
+#!/usr/bin/python
+# -*- encoding: utf-8 -*-
+
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torchvision
+
+from resnet import Resnet18
+# from modules.bn import InPlaceABNSync as BatchNorm2d
+
+
+class ConvBNReLU(nn.Module):
+    def __init__(self, in_chan, out_chan, ks=3, stride=1, padding=1, *args, **kwargs):
+        super(ConvBNReLU, self).__init__()
+        self.conv = nn.Conv2d(in_chan,
+                out_chan,
+                kernel_size = ks,
+                stride = stride,
+                padding = padding,
+                bias = False)
+        self.bn = nn.BatchNorm2d(out_chan)
+        self.init_weight()
+
+    def forward(self, x):
+        x = self.conv(x)
+        x = F.relu(self.bn(x))
+        return x
+
+    def init_weight(self):
+        for ly in self.children():
+            if isinstance(ly, nn.Conv2d):
+                nn.init.kaiming_normal_(ly.weight, a=1)
+                if not ly.bias is None: nn.init.constant_(ly.bias, 0)
+
+class BiSeNetOutput(nn.Module):
+    def __init__(self, in_chan, mid_chan, n_classes, *args, **kwargs):
+        super(BiSeNetOutput, self).__init__()
+        self.conv = ConvBNReLU(in_chan, mid_chan, ks=3, stride=1, padding=1)
+        self.conv_out = nn.Conv2d(mid_chan, n_classes, kernel_size=1, bias=False)
+        self.init_weight()
+
+    def forward(self, x):
+        x = self.conv(x)
+        x = self.conv_out(x)
+        return x
+
+    def init_weight(self):
+        for ly in self.children():
+            if isinstance(ly, nn.Conv2d):
+                nn.init.kaiming_normal_(ly.weight, a=1)
+                if not ly.bias is None: nn.init.constant_(ly.bias, 0)
+
+    def get_params(self):
+        wd_params, nowd_params = [], []
+        for name, module in self.named_modules():
+            if isinstance(module, nn.Linear) or isinstance(module, nn.Conv2d):
+                wd_params.append(module.weight)
+                if not module.bias is None:
+                    nowd_params.append(module.bias)
+            elif isinstance(module, nn.BatchNorm2d):
+                nowd_params += list(module.parameters())
+        return wd_params, nowd_params
+
+
+class AttentionRefinementModule(nn.Module):
+    def __init__(self, in_chan, out_chan, *args, **kwargs):
+        super(AttentionRefinementModule, self).__init__()
+        self.conv = ConvBNReLU(in_chan, out_chan, ks=3, stride=1, padding=1)
+        self.conv_atten = nn.Conv2d(out_chan, out_chan, kernel_size= 1, bias=False)
+        self.bn_atten = nn.BatchNorm2d(out_chan)
+        self.sigmoid_atten = nn.Sigmoid()
+        self.init_weight()
+
+    def forward(self, x):
+        feat = self.conv(x)
+        atten = F.avg_pool2d(feat, feat.size()[2:])
+        atten = self.conv_atten(atten)
+        atten = self.bn_atten(atten)
+        atten = self.sigmoid_atten(atten)
+        out = torch.mul(feat, atten)
+        return out
+
+    def init_weight(self):
+        for ly in self.children():
+            if isinstance(ly, nn.Conv2d):
+                nn.init.kaiming_normal_(ly.weight, a=1)
+                if not ly.bias is None: nn.init.constant_(ly.bias, 0)
+
+
+class ContextPath(nn.Module):
+    def __init__(self, *args, **kwargs):
+        super(ContextPath, self).__init__()
+        self.resnet = Resnet18()
+        self.arm16 = AttentionRefinementModule(256, 128)
+        self.arm32 = AttentionRefinementModule(512, 128)
+        self.conv_head32 = ConvBNReLU(128, 128, ks=3, stride=1, padding=1)
+        self.conv_head16 = ConvBNReLU(128, 128, ks=3, stride=1, padding=1)
+        self.conv_avg = ConvBNReLU(512, 128, ks=1, stride=1, padding=0)
+
+        self.init_weight()
+
+    def forward(self, x):
+        H0, W0 = x.size()[2:]
+        feat8, feat16, feat32 = self.resnet(x)
+        H8, W8 = feat8.size()[2:]
+        H16, W16 = feat16.size()[2:]
+        H32, W32 = feat32.size()[2:]
+
+        avg = F.avg_pool2d(feat32, feat32.size()[2:])
+        avg = self.conv_avg(avg)
+        avg_up = F.interpolate(avg, (H32, W32), mode='nearest')
+
+        feat32_arm = self.arm32(feat32)
+        feat32_sum = feat32_arm + avg_up
+        feat32_up = F.interpolate(feat32_sum, (H16, W16), mode='nearest')
+        feat32_up = self.conv_head32(feat32_up)
+
+        feat16_arm = self.arm16(feat16)
+        feat16_sum = feat16_arm + feat32_up
+        feat16_up = F.interpolate(feat16_sum, (H8, W8), mode='nearest')
+        feat16_up = self.conv_head16(feat16_up)
+
+        return feat8, feat16_up, feat32_up  # x8, x8, x16
+
+    def init_weight(self):
+        for ly in self.children():
+            if isinstance(ly, nn.Conv2d):
+                nn.init.kaiming_normal_(ly.weight, a=1)
+                if not ly.bias is None: nn.init.constant_(ly.bias, 0)
+
+    def get_params(self):
+        wd_params, nowd_params = [], []
+        for name, module in self.named_modules():
+            if isinstance(module, (nn.Linear, nn.Conv2d)):
+                wd_params.append(module.weight)
+                if not module.bias is None:
+                    nowd_params.append(module.bias)
+            elif isinstance(module, nn.BatchNorm2d):
+                nowd_params += list(module.parameters())
+        return wd_params, nowd_params
+
+
+### This is not used, since I replace this with the resnet feature with the same size
+class SpatialPath(nn.Module):
+    def __init__(self, *args, **kwargs):
+        super(SpatialPath, self).__init__()
+        self.conv1 = ConvBNReLU(3, 64, ks=7, stride=2, padding=3)
+        self.conv2 = ConvBNReLU(64, 64, ks=3, stride=2, padding=1)
+        self.conv3 = ConvBNReLU(64, 64, ks=3, stride=2, padding=1)
+        self.conv_out = ConvBNReLU(64, 128, ks=1, stride=1, padding=0)
+        self.init_weight()
+
+    def forward(self, x):
+        feat = self.conv1(x)
+        feat = self.conv2(feat)
+        feat = self.conv3(feat)
+        feat = self.conv_out(feat)
+        return feat
+
+    def init_weight(self):
+        for ly in self.children():
+            if isinstance(ly, nn.Conv2d):
+                nn.init.kaiming_normal_(ly.weight, a=1)
+                if not ly.bias is None: nn.init.constant_(ly.bias, 0)
+
+    def get_params(self):
+        wd_params, nowd_params = [], []
+        for name, module in self.named_modules():
+            if isinstance(module, nn.Linear) or isinstance(module, nn.Conv2d):
+                wd_params.append(module.weight)
+                if not module.bias is None:
+                    nowd_params.append(module.bias)
+            elif isinstance(module, nn.BatchNorm2d):
+                nowd_params += list(module.parameters())
+        return wd_params, nowd_params
+
+
+class FeatureFusionModule(nn.Module):
+    def __init__(self, in_chan, out_chan, *args, **kwargs):
+        super(FeatureFusionModule, self).__init__()
+        self.convblk = ConvBNReLU(in_chan, out_chan, ks=1, stride=1, padding=0)
+        self.conv1 = nn.Conv2d(out_chan,
+                out_chan//4,
+                kernel_size = 1,
+                stride = 1,
+                padding = 0,
+                bias = False)
+        self.conv2 = nn.Conv2d(out_chan//4,
+                out_chan,
+                kernel_size = 1,
+                stride = 1,
+                padding = 0,
+                bias = False)
+        self.relu = nn.ReLU(inplace=True)
+        self.sigmoid = nn.Sigmoid()
+        self.init_weight()
+
+    def forward(self, fsp, fcp):
+        fcat = torch.cat([fsp, fcp], dim=1)
+        feat = self.convblk(fcat)
+        atten = F.avg_pool2d(feat, feat.size()[2:])
+        atten = self.conv1(atten)
+        atten = self.relu(atten)
+        atten = self.conv2(atten)
+        atten = self.sigmoid(atten)
+        feat_atten = torch.mul(feat, atten)
+        feat_out = feat_atten + feat
+        return feat_out
+
+    def init_weight(self):
+        for ly in self.children():
+            if isinstance(ly, nn.Conv2d):
+                nn.init.kaiming_normal_(ly.weight, a=1)
+                if not ly.bias is None: nn.init.constant_(ly.bias, 0)
+
+    def get_params(self):
+        wd_params, nowd_params = [], []
+        for name, module in self.named_modules():
+            if isinstance(module, nn.Linear) or isinstance(module, nn.Conv2d):
+                wd_params.append(module.weight)
+                if not module.bias is None:
+                    nowd_params.append(module.bias)
+            elif isinstance(module, nn.BatchNorm2d):
+                nowd_params += list(module.parameters())
+        return wd_params, nowd_params
+
+
+class BiSeNet(nn.Module):
+    def __init__(self, n_classes, *args, **kwargs):
+        super(BiSeNet, self).__init__()
+        self.cp = ContextPath()
+        ## here self.sp is deleted
+        self.ffm = FeatureFusionModule(256, 256)
+        self.conv_out = BiSeNetOutput(256, 256, n_classes)
+        self.conv_out16 = BiSeNetOutput(128, 64, n_classes)
+        self.conv_out32 = BiSeNetOutput(128, 64, n_classes)
+        self.init_weight()
+
+    def forward(self, x):
+        H, W = x.size()[2:]
+        feat_res8, feat_cp8, feat_cp16 = self.cp(x)  # here return res3b1 feature
+        feat_sp = feat_res8  # use res3b1 feature to replace spatial path feature
+        feat_fuse = self.ffm(feat_sp, feat_cp8)
+
+        feat_out = self.conv_out(feat_fuse)
+        feat_out16 = self.conv_out16(feat_cp8)
+        feat_out32 = self.conv_out32(feat_cp16)
+
+        feat_out = F.interpolate(feat_out, (H, W), mode='bilinear', align_corners=True)
+        feat_out16 = F.interpolate(feat_out16, (H, W), mode='bilinear', align_corners=True)
+        feat_out32 = F.interpolate(feat_out32, (H, W), mode='bilinear', align_corners=True)
+        return feat_out, feat_out16, feat_out32
+
+    def init_weight(self):
+        for ly in self.children():
+            if isinstance(ly, nn.Conv2d):
+                nn.init.kaiming_normal_(ly.weight, a=1)
+                if not ly.bias is None: nn.init.constant_(ly.bias, 0)
+
+    def get_params(self):
+        wd_params, nowd_params, lr_mul_wd_params, lr_mul_nowd_params = [], [], [], []
+        for name, child in self.named_children():
+            child_wd_params, child_nowd_params = child.get_params()
+            if isinstance(child, FeatureFusionModule) or isinstance(child, BiSeNetOutput):
+                lr_mul_wd_params += child_wd_params
+                lr_mul_nowd_params += child_nowd_params
+            else:
+                wd_params += child_wd_params
+                nowd_params += child_nowd_params
+        return wd_params, nowd_params, lr_mul_wd_params, lr_mul_nowd_params
+
+
+if __name__ == "__main__":
+    net = BiSeNet(19)
+    net.cuda()
+    net.eval()
+    in_ten = torch.randn(16, 3, 640, 480).cuda()
+    out, out16, out32 = net(in_ten)
+    print(out.shape)
+
+    net.get_params()

face_parsing-main/prepropess_data.py

@@ -0,0 +1,47 @@
+# -*- encoding: utf-8 -*-
+#function : 训练样本预处理
+
+import os
+import os.path as osp
+import cv2
+from transform import *
+from PIL import Image
+
+if __name__ == "__main__":
+
+    image_size = 512# 样本分辨率
+
+    face_data = './CelebAMask-HQ/CelebA-HQ-img'
+    face_sep_mask = './CelebAMask-HQ/CelebAMask-HQ-mask-anno'
+    mask_path = './CelebAMask-HQ/mask_{}'.format(image_size)
+
+    if not os.path.exists(mask_path):
+        os.mkdir(mask_path)
+
+    counter = 0
+    total = 0
+    for i in range(15):
+
+        atts = ['skin', 'l_brow', 'r_brow', 'l_eye', 'r_eye', 'eye_g', 'l_ear', 'r_ear', 'ear_r',
+                'nose', 'mouth', 'u_lip', 'l_lip', 'neck', 'neck_l', 'cloth', 'hair', 'hat']
+
+        for j in range(i * 2000, (i + 1) * 2000):
+
+            mask = np.zeros((512, 512))
+
+            for l, att in enumerate(atts, 1):
+                total += 1
+                file_name = ''.join([str(j).rjust(5, '0'), '_', att, '.png'])
+                path = osp.join(face_sep_mask, str(i), file_name)
+
+                if os.path.exists(path):
+                    counter += 1
+                    sep_mask = np.array(Image.open(path).convert('P'))
+
+                    mask[sep_mask == 225] = l
+            if image_size != 512:
+                mask = cv2.resize(mask,(image_size,image_size),interpolation=cv2.INTER_NEAREST)
+            cv2.imwrite('{}/{}.png'.format(mask_path, j), mask)
+            print(j)
+
+    print(counter, total)

face_parsing-main/resnet.py

@@ -0,0 +1,109 @@
+#!/usr/bin/python
+# -*- encoding: utf-8 -*-
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.utils.model_zoo as modelzoo
+
+# from modules.bn import InPlaceABNSync as BatchNorm2d
+
+resnet18_url = 'https://download.pytorch.org/models/resnet18-5c106cde.pth'
+
+
+def conv3x3(in_planes, out_planes, stride=1):
+    """3x3 convolution with padding"""
+    return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
+                     padding=1, bias=False)
+
+
+class BasicBlock(nn.Module):
+    def __init__(self, in_chan, out_chan, stride=1):
+        super(BasicBlock, self).__init__()
+        self.conv1 = conv3x3(in_chan, out_chan, stride)
+        self.bn1 = nn.BatchNorm2d(out_chan)
+        self.conv2 = conv3x3(out_chan, out_chan)
+        self.bn2 = nn.BatchNorm2d(out_chan)
+        self.relu = nn.ReLU(inplace=True)
+        self.downsample = None
+        if in_chan != out_chan or stride != 1:
+            self.downsample = nn.Sequential(
+                nn.Conv2d(in_chan, out_chan,
+                          kernel_size=1, stride=stride, bias=False),
+                nn.BatchNorm2d(out_chan),
+                )
+
+    def forward(self, x):
+        residual = self.conv1(x)
+        residual = F.relu(self.bn1(residual))
+        residual = self.conv2(residual)
+        residual = self.bn2(residual)
+
+        shortcut = x
+        if self.downsample is not None:
+            shortcut = self.downsample(x)
+
+        out = shortcut + residual
+        out = self.relu(out)
+        return out
+
+
+def create_layer_basic(in_chan, out_chan, bnum, stride=1):
+    layers = [BasicBlock(in_chan, out_chan, stride=stride)]
+    for i in range(bnum-1):
+        layers.append(BasicBlock(out_chan, out_chan, stride=1))
+    return nn.Sequential(*layers)
+
+
+class Resnet18(nn.Module):
+    def __init__(self):
+        super(Resnet18, self).__init__()
+        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3,
+                               bias=False)
+        self.bn1 = nn.BatchNorm2d(64)
+        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
+        self.layer1 = create_layer_basic(64, 64, bnum=2, stride=1)
+        self.layer2 = create_layer_basic(64, 128, bnum=2, stride=2)
+        self.layer3 = create_layer_basic(128, 256, bnum=2, stride=2)
+        self.layer4 = create_layer_basic(256, 512, bnum=2, stride=2)
+        self.init_weight()
+
+    def forward(self, x):
+        x = self.conv1(x)
+        x = F.relu(self.bn1(x))
+        x = self.maxpool(x)
+
+        x = self.layer1(x)
+        feat8 = self.layer2(x) # 1/8
+        feat16 = self.layer3(feat8) # 1/16
+        feat32 = self.layer4(feat16) # 1/32
+        return feat8, feat16, feat32
+
+    def init_weight(self):
+        state_dict = modelzoo.load_url(resnet18_url)
+        self_state_dict = self.state_dict()
+        for k, v in state_dict.items():
+            if 'fc' in k: continue
+            self_state_dict.update({k: v})
+        self.load_state_dict(self_state_dict)
+
+    def get_params(self):
+        wd_params, nowd_params = [], []
+        for name, module in self.named_modules():
+            if isinstance(module, (nn.Linear, nn.Conv2d)):
+                wd_params.append(module.weight)
+                if not module.bias is None:
+                    nowd_params.append(module.bias)
+            elif isinstance(module,  nn.BatchNorm2d):
+                nowd_params += list(module.parameters())
+        return wd_params, nowd_params
+
+
+if __name__ == "__main__":
+    net = Resnet18()
+    x = torch.randn(16, 3, 224, 224)
+    out = net(x)
+    print(out[0].size())
+    print(out[1].size())
+    print(out[2].size())
+    net.get_params()

face_parsing-main/softmask.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Module Function:
+Generates a soft-edge nose mask (grayscale 0..255) from a single 512x1536 (WxH) image.
+
+Wrapper Function:
+    make_softmask_pil(img: PIL.Image, weights: Path, inference_fp: Path,
+                      device="cpu", y_top=400, sigma=4.0, nose_id=10)
+Command Line:
+    python softmask_module.py --in_path ./datasets/train --weights ./fp_512.pth \
+        --device cpu --out_dir ./result_soft --y_top 400 --sigma 4
+"""
+
+import argparse
+import sys
+import subprocess
+import tempfile
+from pathlib import Path
+import numpy as np
+from PIL import Image, ImageFilter
+
+# ---------- Utility Functions ----------
+def ensure_dir(p: Path):
+    p.mkdir(parents=True, exist_ok=True)
+
+def load_rgb(path: Path) -> Image.Image:
+    return Image.open(path).convert("RGB")
+
+def run_face_parsing(inference_fp: Path, images_dir: Path, weights: Path,
+                     device: str, save_idx_dir: Path, img_size: int = 512):
+    cmd = [
+        sys.executable, str(inference_fp),
+        "--image_dir", str(images_dir),
+        "--weights", str(weights),
+        "--img_size", str(img_size),
+        "--device", device,
+        "--save_idx", str(save_idx_dir),
+    ]
+    print("[INFO] face parsing:", " ".join(cmd))
+    subprocess.run(cmd, check=True)
+
+def load_idx(idx_path: Path) -> np.ndarray:
+    if idx_path.suffix.lower() == ".npy":
+        return np.load(idx_path)
+    return np.array(Image.open(idx_path).convert("L"))
+
+def build_full_mask(idx_512: np.ndarray, H: int, y_top: int, nose_id: int) -> Image.Image:
+    """Back-project the 512x512 nose idx image to the 512xH (H=1536) image location"""
+    assert idx_512.shape == (512, 512), f"expect 512x512, got {idx_512.shape}"
+    out = np.zeros((H, 512), dtype=np.uint8)
+    nose_bin = (idx_512 == nose_id).astype(np.uint8) * 255
+    y1 = max(0, min(H - 512, y_top))
+    out[y1:y1+512, :] = nose_bin
+    return Image.fromarray(out, mode="L")
+
+# ---------- Encapsulated function (direct external call) ----------
+def make_softmask_pil(img: Image.Image, weights: Path, inference_fp: Path,
+                      device="cpu", y_top=400, sigma=4.0, nose_id=10) -> Image.Image:
+    """
+        Input:
+        img: PIL.Image, must be 512x1536 (WxH)
+        weights: Path, face parsing weights
+        inference_fp: Path, inference.py path
+        device: "cpu" / "cuda:0"
+        y_top: 512x512 square starting at row y_top
+        sigma: Gaussian softening radius
+        nose_id: ID of the nose class in face parsing (default 10)
+        Output:
+        512x1536 grayscale PIL.Image (white = nose, 0-255 soft edges)
+    """
+    img = img.convert("RGB")
+    W, H = img.size
+    if (W, H) != (512, 1536):
+        raise ValueError(f"expect 512x1536 (WxH), got {W}x{H}")
+
+    # Cut out 512x512 blocks
+    y1 = max(0, min(1536 - 512, y_top))
+    patch = img.crop((0, y1, 512, y1 + 512))
+
+    # Run inference in a temporary directory
+    with tempfile.TemporaryDirectory(prefix="fp_soft_") as td:
+        td = Path(td)
+        d_in = td / "in"; d_idx = td / "idx"
+        ensure_dir(d_in); ensure_dir(d_idx)
+        sq_path = d_in / "tmp.png"
+        patch.save(sq_path)
+
+        run_face_parsing(inference_fp, d_in, weights, device, d_idx, img_size=512)
+
+        idx_npy = d_idx / "tmp.npy"
+        idx_png = d_idx / "tmp.png"
+        if idx_npy.exists():
+            idx = load_idx(idx_npy)
+        elif idx_png.exists():
+            idx = load_idx(idx_png)
+        else:
+            raise RuntimeError(f"no idx file in {d_idx}")
+
+        hard_mask = build_full_mask(idx, H=1536, y_top=y1, nose_id=nose_id)
+
+        # ---- Softened part ----
+        soft = hard_mask.filter(ImageFilter.GaussianBlur(radius=float(sigma)))
+        return soft
+
+# ---------- Command line entry ----------
+def main():
+    ap = argparse.ArgumentParser(description="生成 512x1536 软边鼻部 mask（支持批量）")
+    ap.add_argument("--in_path", required=True, help="单图或目录路径（512x1536）")
+    ap.add_argument("--weights", required=True, help="fp_512.pth 路径")
+    ap.add_argument("--inference_fp", default="inference.py", help="face parsing 脚本路径")
+    ap.add_argument("--device", default="cpu", help="cpu / cuda:0 / cuda:1")
+    ap.add_argument("--out_dir", required=True, help="输出目录")
+    ap.add_argument("--y_top", type=int, default=400, help="起始 y 坐标")
+    ap.add_argument("--sigma", type=float, default=4.0, help="高斯软化半径")
+    ap.add_argument("--nose_id", type=int, default=10, help="face parsing 中鼻子类别 ID")
+    args = ap.parse_args()
+
+    in_path = Path(args.in_path)
+    ensure_dir(Path(args.out_dir))
+
+    if in_path.is_file():
+        img = load_rgb(in_path)
+        mask = make_softmask_pil(img, Path(args.weights), Path(args.inference_fp),
+                                 device=args.device, y_top=args.y_top,
+                                 sigma=args.sigma, nose_id=args.nose_id)
+        out_path = Path(args.out_dir) / f"{in_path.stem}.png"
+        mask.save(out_path)
+        print(f"[OK] saved: {out_path}")
+
+    elif in_path.is_dir():
+        imgs = sorted([p for p in in_path.iterdir() if p.suffix.lower() in [".png", ".jpg", ".jpeg", ".bmp", ".webp"]])
+        for p in imgs:
+            img = load_rgb(p)
+            mask = make_softmask_pil(img, Path(args.weights), Path(args.inference_fp),
+                                     device=args.device, y_top=args.y_top,
+                                     sigma=args.sigma, nose_id=args.nose_id)
+            out_path = Path(args.out_dir) / f"{p.stem}.png"
+            mask.save(out_path)
+            print(f"[OK] saved: {out_path}")
+    else:
+        raise SystemExit(f"[ERR] invalid in_path: {in_path}")
+
+if __name__ == "__main__":
+    main()

face_parsing-main/test_nose_mask.py

@@ -0,0 +1,227 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+从 1024x1536（宽x高）拼接图片中，直接生成左半边 real_A 的 512x1536 鼻部二值掩膜（白=255，黑=0）。
+内部自动：
+1) 从左半边 A 截取 y_top 开始的 512x512 方块；
+2) 调用你们现有的 inference.py 做 face parsing（ID=10 为鼻子）；
+3) 将鼻子区域回投影到 512x1536 的正确位置，输出 PNG（二值）。
+
+用法示例：
+python test_nose_mask.py \
+  --in_path ./datasets/test \
+  --weights ./fp_512.pth \
+  --device cpu \
+  --out_dir ./result_test \
+  --y_top 400 --patch 512
+
+支持：输入是单图文件，或目录（批量处理所有常见图片后缀）。
+"""
+
+import argparse
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+import numpy as np
+from PIL import Image
+
+
+IMG_EXTS = {".png", ".jpg", ".jpeg", ".bmp", ".webp"}
+
+
+def load_image_rgb(path: Path) -> Image.Image:
+    im = Image.open(path).convert("RGB")
+    return im
+
+
+def ensure_dir(p: Path):
+    p.mkdir(parents=True, exist_ok=True)
+
+
+def run_face_parsing_batch(
+    inference_fp: Path,
+    images_dir: Path,
+    weights: Path,
+    device: str,
+    save_idx_dir: Path,
+    img_size: int = 512,
+):
+    """
+    以命令行方式调用你们现有的 inference.py
+    只保存 idx（每像素类别图），我们随后读取其中的鼻子 ID=10。
+    """
+    cmd = [
+        sys.executable,             # 当前 python
+        str(inference_fp),
+        "--image_dir", str(images_dir),
+        "--weights", str(weights),
+        "--img_size", str(img_size),
+        "--device", device,
+        "--save_idx", str(save_idx_dir),
+    ]
+    print("[INFO] Running face parsing:", " ".join(cmd))
+    subprocess.run(cmd, check=True)
+
+
+def load_idx_map(idx_path: Path) -> np.ndarray:
+    """
+    既兼容 .npy（很多 face parsing 脚本的做法），也兼容灰度 .png。
+    返回 HxW 的整型 numpy 数组。
+    """
+    if idx_path.suffix.lower() == ".npy":
+        return np.load(idx_path)
+    # 假设是灰度 PNG，像素值就是类别 id
+    arr = np.array(Image.open(idx_path).convert("L"))
+    return arr
+
+
+def build_leftA_nose_mask_fullh(idx_map: np.ndarray, H: int, y_top: int, nose_id: int) -> np.ndarray:
+    """
+    idx_map: 512x512（face parsing 的方块输出，ID=10 为鼻子）
+    H: 1536；输出为 512xH 的二值 mask（0/255），鼻子区域放在 [y_top:y_top+512]
+    """
+    assert idx_map.shape == (512, 512), f"idx_map shape must be 512x512, got {idx_map.shape}"
+    out = np.zeros((H, 512), dtype=np.uint8)  # HxW，左半边宽=512
+    nose_bin = (idx_map == nose_id).astype(np.uint8) * 255
+    y1 = max(0, min(H - 512, y_top))
+    out[y1:y1 + 512, :] = nose_bin
+    return out
+
+
+def process_one(
+    img_path: Path,
+    out_dir: Path,
+    inference_fp: Path,
+    weights: Path,
+    device: str,
+    y_top: int,
+    patch: int,
+    nose_id: int,
+):
+    """
+    单图处理：
+    - 读入 1024x1536 宽x高图片
+    - 取左半边 A（0:512, 0:1536）
+    - 截取 A[y_top:y_top+512, 0:512] → 512x512
+    - face parsing，取 ID=10
+    - 回填到 512x1536 高度位置
+    - 存为 PNG（白=255，黑=0）
+    """
+    stem = img_path.stem
+    print(f"[INFO] Processing {img_path.name}")
+
+    # 读原图并校验尺寸（宽x高）
+    im = load_image_rgb(img_path)
+    W, H = im.size  # PIL: (width, height)
+    if (W, H) != (1024, 1536):
+        raise SystemExit(f"[ERR] {img_path.name}: expected 1024x1536 (WxH), got {W}x{H}")
+
+    # 取左半边 A（x:0~512, y:0~1536）
+    A = im.crop((0, 0, 512, 1536))  # (left, top, right, bottom)
+
+    # 取 512x512 的方块（从 y_top 开始）
+    if patch != 512:
+        raise SystemExit("[ERR] 当前实现假设 patch=512 以匹配模型输入。")
+    y1 = max(0, min(1536 - 512, y_top))
+    A_sq = A.crop((0, y1, 512, y1 + 512))  # 512x512
+
+    # 在临时目录里做推理
+    with tempfile.TemporaryDirectory(prefix="fp_leftA_") as td:
+        td = Path(td)
+        tmp_in = td / "in"
+        tmp_idx = td / "idx"
+        ensure_dir(tmp_in)
+        ensure_dir(tmp_idx)
+
+        # 保存 512x512 方块
+        sq_path = tmp_in / f"{stem}.png"
+        A_sq.save(sq_path)
+
+        # 调用现有 face parsing 推理
+        run_face_parsing_batch(
+            inference_fp=inference_fp,
+            images_dir=tmp_in,
+            weights=weights,
+            device=device,
+            save_idx_dir=tmp_idx,
+            img_size=512,
+        )
+
+        # 读取 idx 图（支持 .npy 或 .png）
+        # 可能文件名就是 stem.npy / stem.png
+        cand_npy = tmp_idx / f"{stem}.npy"
+        cand_png = tmp_idx / f"{stem}.png"
+        if cand_npy.exists():
+            idx_map = load_idx_map(cand_npy)
+        elif cand_png.exists():
+            idx_map = load_idx_map(cand_png)
+        else:
+            raise SystemExit(f"[ERR] 未在 {tmp_idx} 找到 {stem}.npy 或 {stem}.png")
+
+        # 构建 512x1536 ��值 mask（鼻子=255）
+        mask_full = build_leftA_nose_mask_fullh(idx_map, H=1536, y_top=y1, nose_id=nose_id)
+
+        # 保存（保持与 A 同宽高：512x1536）
+        ensure_dir(out_dir)
+        out_path = out_dir / f"{stem}.png"
+        Image.fromarray(mask_full, mode="L").save(out_path)
+        print(f"[OK] Saved: {out_path}")
+
+
+def main():
+    ap = argparse.ArgumentParser(description="Make 512x1536 left-A nasal masks directly from 1024x1536 images.")
+    ap.add_argument("--in_path", required=True, help="单图路径或目录路径")
+    ap.add_argument("--weights", required=True, help="fp_512.pth 路径")
+    ap.add_argument("--inference_fp", default="inference.py", help="face parsing 推理脚本路径（默认当前目录下）")
+    ap.add_argument("--device", default="cpu", help="cpu 或 cuda:0 / cuda:1 ...")
+    ap.add_argument("--out_dir", required=True, help="输出目录（生成 512x1536 二值鼻部掩膜）")
+    ap.add_argument("--y_top", type=int, default=400, help="竖向起点（默认 400）")
+    ap.add_argument("--patch", type=int, default=512, help="方块高度（固定 512，匹配模型输入）")
+    ap.add_argument("--nose_id", type=int, default=10, help="face parsing 中鼻子类别 ID（默认 10）")
+    args = ap.parse_args()
+
+    in_path = Path(args.in_path)
+    out_dir = Path(args.out_dir)
+    weights = Path(args.weights)
+    inference_fp = Path(args.inference_fp)
+
+    if not inference_fp.exists():
+        raise SystemExit(f"[ERR] inference.py 不存在：{inference_fp}")
+    if not weights.exists():
+        raise SystemExit(f"[ERR] 权重不存在：{weights}")
+
+    if in_path.is_file():
+        process_one(
+            img_path=in_path,
+            out_dir=out_dir,
+            inference_fp=inference_fp,
+            weights=weights,
+            device=args.device,
+            y_top=args.y_top,
+            patch=args.patch,
+            nose_id=args.nose_id,
+        )
+    elif in_path.is_dir():
+        imgs = sorted([p for p in in_path.iterdir() if p.suffix.lower() in IMG_EXTS])
+        if not imgs:
+            raise SystemExit(f"[ERR] 目录下未找到图片：{in_path}")
+        for p in imgs:
+            process_one(
+                img_path=p,
+                out_dir=out_dir,
+                inference_fp=inference_fp,
+                weights=weights,
+                device=args.device,
+                y_top=args.y_top,
+                patch=args.patch,
+                nose_id=args.nose_id,
+            )
+    else:
+        raise SystemExit(f"[ERR] --in_path 非法：{in_path}")
+
+
+if __name__ == "__main__":
+    main()

face_parsing-main/test_nose_mask_single.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+从单张 512x1536（宽x高）的图片，生成对应的 512x1536 鼻部二值掩膜（白=255，黑=0）。
+
+两种用法：
+1) 作为模块被 import：  from test_nose_mask_single import make_nose_mask_pil
+2) 命令行：python test_nose_mask_single.py --img xxx.png --weights fp_512.pth --inference_fp inference.py --device cpu --out_dir result_single --y_top 400
+"""
+
+import argparse
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+import numpy as np
+from PIL import Image
+
+# ----------------- 工具函数 -----------------
+def ensure_dir(p: Path):
+    p.mkdir(parents=True, exist_ok=True)
+
+def run_face_parsing(
+    inference_fp: Path,
+    image_dir: Path,
+    weights: Path,
+    device: str,
+    save_idx_dir: Path,
+    img_size: int = 512,
+):
+    """调用 inference.py 做 face parsing，并把语义索引图（.npy 或 .png）保存到 save_idx_dir。"""
+    cmd = [
+        sys.executable, str(inference_fp),
+        "--image_dir", str(image_dir),
+        "--weights", str(weights),
+        "--img_size", str(img_size),
+        "--device", device,
+        "--save_idx", str(save_idx_dir),
+    ]
+    print("[INFO] Run:", " ".join(cmd))
+    subprocess.run(cmd, check=True)
+
+def load_idx(idx_path: Path) -> np.ndarray:
+    """读取语义索引图（支持 .npy 或 单通道 .png）。"""
+    if idx_path.suffix.lower() == ".npy":
+        return np.load(idx_path)
+    arr = np.array(Image.open(idx_path).convert("L"))
+    return arr
+
+def build_mask_full(idx_512: np.ndarray, H: int, y_top: int, nose_id: int) -> np.ndarray:
+    """把 512x512 的鼻子索引区域回投影到整幅高 H=1536 的图像上。"""
+    assert idx_512.shape == (512, 512), f"idx must be 512x512, got {idx_512.shape}"
+    out = np.zeros((H, 512), dtype=np.uint8)
+    nose = (idx_512 == nose_id).astype(np.uint8) * 255
+    y1 = max(0, min(H - 512, y_top))
+    out[y1:y1+512, :] = nose
+    return out
+
+# ----------------- 封装函数（给 Flask 直接调用） -----------------
+def make_nose_mask_pil(
+    img: Image.Image,
+    weights: Path,
+    inference_fp: Path,
+    device: str = "cpu",
+    y_top: int = 400,
+    nose_id: int = 10,
+) -> Image.Image:
+    """
+    输入：一张 512x1536 的 PIL.Image（RGB）
+    输出：同尺寸 512x1536 的单通道鼻子掩码 PIL.Image（mode="L", 白=255）
+    """
+    img = img.convert("RGB")
+    W, H = img.size
+    if (W, H) != (512, 1536):
+        raise ValueError(f"期望输入尺寸为 512x1536（宽x高），但收到 {W}x{H}")
+
+    # 1) 按 y_top 裁出 512x512 方块
+    y1 = max(0, min(1536 - 512, y_top))
+    patch = img.crop((0, y1, 512, y1 + 512))
+
+    # 2) 临时目录跑 inference.py
+    with tempfile.TemporaryDirectory(prefix="fp_one_") as td:
+        td = Path(td)
+        tmp_in = td / "in"
+        tmp_idx = td / "idx"
+        ensure_dir(tmp_in); ensure_dir(tmp_idx)
+
+        sq_path = tmp_in / "tmp.png"
+        patch.save(sq_path)
+
+        run_face_parsing(
+            inference_fp=inference_fp,
+            image_dir=tmp_in,
+            weights=weights,
+            device=device,
+            save_idx_dir=tmp_idx,
+            img_size=512,
+        )
+
+        # 3) 读取 parsing 输出
+        npy = tmp_idx / "tmp.npy"
+        png = tmp_idx / "tmp.png"
+        if npy.exists():
+            idx = load_idx(npy)
+        elif png.exists():
+            idx = load_idx(png)
+        else:
+            raise RuntimeError(f"未在 {tmp_idx} 找到 tmp.npy 或 tmp.png")
+
+        # 4) 组装为整幅 512x1536 掩码
+        mask_full = build_mask_full(idx, H=1536, y_top=y1, nose_id=nose_id)
+        return Image.fromarray(mask_full, mode="L")
+
+# ----------------- 保留命令行入口（你原来的用法照常可用） -----------------
+def main():
+    ap = argparse.ArgumentParser(description="Make 512x1536 nasal mask from a single image.")
+    ap.add_argument("--img", required=True, help="输入单图路径（必须 512x1536，宽x高）")
+    ap.add_argument("--weights", required=True, help="fp_512.pth 权重路径")
+    ap.add_argument("--inference_fp", default="inference.py", help="face parsing 推理脚本路径")
+    ap.add_argument("--device", default="cpu", help="cpu 或 cuda:0 等")
+    ap.add_argument("--out_dir", required=True, help="输出目录")
+    ap.add_argument("--y_top", type=int, default=400, help="从何处向下裁 512 方块")
+    ap.add_argument("--nose_id", type=int, default=10, help="鼻子类别 ID")
+    args = ap.parse_args()
+
+    img_path = Path(args.img)
+    im = Image.open(img_path).convert("RGB")
+
+    mask_pil = make_nose_mask_pil(
+        img=im,
+        weights=Path(args.weights),
+        inference_fp=Path(args.inference_fp),
+        device=args.device,
+        y_top=args.y_top,
+        nose_id=args.nose_id,
+    )
+
+    out_dir = Path(args.out_dir); ensure_dir(out_dir)
+    out_path = out_dir / (img_path.stem + ".png")
+    mask_pil.save(out_path)
+    print(f"[OK] Saved: {out_path}")
+
+if __name__ == "__main__":
+    main()

face_parsing-main/train.py

@@ -0,0 +1,157 @@
+# -*- encoding: utf-8 -*-
+
+import os
+os.environ["CUDA_VISIBLE_DEVICES"] = "0"
+from model import BiSeNet
+from face_dataset import FaceMask
+from loss import OhemCELoss
+import torch.optim as Optimizer
+import cv2
+import numpy as np
+
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader
+import torch.nn.functional as F
+
+import os.path as osp
+import time
+import datetime
+import argparse
+
+def set_learning_rate(optimizer, lr):
+    for param_group in optimizer.param_groups:
+        param_group['lr'] = lr
+
+def train(fintune_model,image_size,lr0,path_data,model_exp):
+
+    # config 训练配置
+    max_epoch = 1000
+    n_classes = 19
+    n_img_per_gpu = 16
+    n_workers = 12
+    cropsize = [int(image_size*0.8),int(image_size*0.8)]
+
+    # DataLoader 数据迭代器
+    ds = FaceMask(path_data,img_size = image_size, cropsize=cropsize, mode='train')
+
+    dl = DataLoader(ds,
+                    batch_size = n_img_per_gpu,
+                    shuffle = True,
+                    num_workers = n_workers,
+                    pin_memory = True,
+                    drop_last = True)
+
+    # model
+    ignore_idx = -100
+    # 构建模型
+    use_cuda = torch.cuda.is_available()
+    device = torch.device("cuda:0" if use_cuda else "cpu")
+    net = BiSeNet(n_classes=n_classes)
+    net = net.to(device)
+    # 加载预训练模型
+    if os.access(fintune_model,os.F_OK) and (fintune_model is not None):# checkpoint
+        chkpt = torch.load(fintune_model, map_location=device)
+        net.load_state_dict(chkpt)
+        print('load fintune model : {}'.format(fintune_model))
+    else:
+        print('no fintune model')
+    # 构建损失函数
+    score_thres = 0.7
+    n_min = n_img_per_gpu * cropsize[0] * cropsize[1]//16
+    LossP = OhemCELoss(thresh=score_thres, n_min=n_min, ignore_lb=ignore_idx)
+    Loss2 = OhemCELoss(thresh=score_thres, n_min=n_min, ignore_lb=ignore_idx)
+    Loss3 = OhemCELoss(thresh=score_thres, n_min=n_min, ignore_lb=ignore_idx)
+
+    ## optimizer
+    momentum = 0.9
+    weight_decay = 5e-4
+    lr_start = lr0
+    # 构建优化器
+    optim = Optimizer.SGD(
+            net.parameters(),
+            lr = lr_start,
+            momentum = momentum,
+            weight_decay = weight_decay)
+
+    # train loop
+    msg_iter = 50
+    loss_avg = []
+    st = glob_st = time.time()
+    # diter = iter(dl)
+    epoch = 0
+    flag_change_lr_cnt = 0 # 学习率更新计数器
+    init_lr = lr_start # 学习率
+
+    best_loss = np.inf
+    loss_mean = 0. # 损失均值
+    loss_idx = 0. # 损失计算计数器
+    # 训练
+    print('start training ~')
+    it = 0
+    for epoch in range(max_epoch):
+        net.train()
+        # 学习率更新策略
+        if loss_mean!=0.:
+            if best_loss > (loss_mean/loss_idx):
+                flag_change_lr_cnt = 0
+                best_loss = (loss_mean/loss_idx)
+            else:
+                flag_change_lr_cnt += 1
+
+                if flag_change_lr_cnt > 30:
+                    init_lr = init_lr*0.1
+                    set_learning_rate(optim, init_lr)
+                    flag_change_lr_cnt = 0
+
+        loss_mean = 0. # 损失均值
+        loss_idx = 0. # 损失计算计数器
+
+        for i, (im, lb) in enumerate(dl):
+
+            im = im.cuda()
+            lb = lb.cuda()
+            H, W = im.size()[2:]
+            lb = torch.squeeze(lb, 1)
+
+            optim.zero_grad()
+            out, out16, out32 = net(im)
+            lossp = LossP(out, lb)
+            loss2 = Loss2(out16, lb)
+            loss3 = Loss3(out32, lb)
+            loss = lossp + loss2 + loss3
+
+            loss_mean += loss.item()
+            loss_idx += 1.
+
+            loss.backward()
+            optim.step()
+
+            if it % msg_iter == 0:
+
+                print('epoch <{}/{}> -->> <{}/{}> -> iter {} : loss {:.5f}, loss_mean :{:.5f}, best_loss :{:.5f},lr :{:.6f},batch_size : {},img_size :{}'.\
+                format(epoch,max_epoch,i,int(ds.__len__()/n_img_per_gpu),it,loss.item(),loss_mean/loss_idx,best_loss,init_lr,n_img_per_gpu,image_size))
+
+                if (it) % 500 == 0:
+                    state = net.module.state_dict() if hasattr(net, 'module') else net.state_dict()
+                    torch.save(state, model_exp+'fp_{}_latest.pth'.format(image_size))
+            it += 1
+        torch.save(state, model_exp+'fp_{}_epoch-{}.pth'.format(image_size,epoch))
+
+if __name__ == "__main__":
+    image_size = 512
+    lr0 = 1e-4
+    model_exp = './model_exp/'
+    path_data = './CelebAMask-HQ/'
+    if not osp.exists(model_exp):
+        os.makedirs(model_exp)
+
+
+    loc_time = time.localtime()
+    model_exp += time.strftime("%Y-%m-%d_%H-%M-%S", loc_time)+'/'
+    if not osp.exists(model_exp):
+        os.makedirs(model_exp)
+
+    fintune_model = './weights/fp0.pth'
+
+    train(fintune_model,image_size,lr0,path_data,model_exp)

face_parsing-main/transform.py

@@ -0,0 +1,128 @@
+# -*- encoding: utf-8 -*-
+
+
+from PIL import Image
+import PIL.ImageEnhance as ImageEnhance
+import random
+import numpy as np
+
+class RandomCrop(object):
+    def __init__(self, size, *args, **kwargs):
+        self.size = size
+
+    def __call__(self, im_lb):
+        im = im_lb['im']
+        lb = im_lb['lb']
+        assert im.size == lb.size
+        W, H = self.size
+        w, h = im.size
+
+        if (W, H) == (w, h): return dict(im=im, lb=lb)
+        if w < W or h < H:
+            scale = float(W) / w if w < h else float(H) / h
+            w, h = int(scale * w + 1), int(scale * h + 1)
+            im = im.resize((w, h), Image.BILINEAR)
+            lb = lb.resize((w, h), Image.NEAREST)
+        sw, sh = random.random() * (w - W), random.random() * (h - H)
+        crop = int(sw), int(sh), int(sw) + W, int(sh) + H
+        return dict(
+                im = im.crop(crop),
+                lb = lb.crop(crop)
+                    )
+
+
+class HorizontalFlip(object):
+    def __init__(self, p=0.5, *args, **kwargs):
+        self.p = p
+
+    def __call__(self, im_lb):
+        if random.random() > self.p:
+            return im_lb
+        else:
+            im = im_lb['im']
+            lb = im_lb['lb']
+
+            # atts = [1 'skin', 2 'l_brow', 3 'r_brow', 4 'l_eye', 5 'r_eye', 6 'eye_g', 7 'l_ear', 8 'r_ear', 9 'ear_r',
+            #         10 'nose', 11 'mouth', 12 'u_lip', 13 'l_lip', 14 'neck', 15 'neck_l', 16 'cloth', 17 'hair', 18 'hat']
+
+            flip_lb = np.array(lb)
+            flip_lb[lb == 2] = 3
+            flip_lb[lb == 3] = 2
+            flip_lb[lb == 4] = 5
+            flip_lb[lb == 5] = 4
+            flip_lb[lb == 7] = 8
+            flip_lb[lb == 8] = 7
+            flip_lb = Image.fromarray(flip_lb)
+            return dict(im = im.transpose(Image.FLIP_LEFT_RIGHT),
+                        lb = flip_lb.transpose(Image.FLIP_LEFT_RIGHT),
+                    )
+
+
+class RandomScale(object):
+    def __init__(self, scales=(1, ), *args, **kwargs):
+        self.scales = scales
+
+    def __call__(self, im_lb):
+        im = im_lb['im']
+        lb = im_lb['lb']
+        W, H = im.size
+        scale = random.choice(self.scales)
+        w, h = int(W * scale), int(H * scale)
+        return dict(im = im.resize((w, h), Image.BILINEAR),
+                    lb = lb.resize((w, h), Image.NEAREST),
+                )
+
+
+class ColorJitter(object):
+    def __init__(self, brightness=None, contrast=None, saturation=None, *args, **kwargs):
+        if not brightness is None and brightness>0:
+            self.brightness = [max(1-brightness, 0), 1+brightness]
+        if not contrast is None and contrast>0:
+            self.contrast = [max(1-contrast, 0), 1+contrast]
+        if not saturation is None and saturation>0:
+            self.saturation = [max(1-saturation, 0), 1+saturation]
+
+    def __call__(self, im_lb):
+        im = im_lb['im']
+        lb = im_lb['lb']
+        r_brightness = random.uniform(self.brightness[0], self.brightness[1])
+        r_contrast = random.uniform(self.contrast[0], self.contrast[1])
+        r_saturation = random.uniform(self.saturation[0], self.saturation[1])
+        im = ImageEnhance.Brightness(im).enhance(r_brightness)
+        im = ImageEnhance.Contrast(im).enhance(r_contrast)
+        im = ImageEnhance.Color(im).enhance(r_saturation)
+        return dict(im = im,
+                    lb = lb,
+                )
+
+
+class MultiScale(object):
+    def __init__(self, scales):
+        self.scales = scales
+
+    def __call__(self, img):
+        W, H = img.size
+        sizes = [(int(W*ratio), int(H*ratio)) for ratio in self.scales]
+        imgs = []
+        [imgs.append(img.resize(size, Image.BILINEAR)) for size in sizes]
+        return imgs
+
+
+class Compose(object):
+    def __init__(self, do_list):
+        self.do_list = do_list
+
+    def __call__(self, im_lb):
+        for comp in self.do_list:
+            im_lb = comp(im_lb)
+        return im_lb
+
+
+
+
+if __name__ == '__main__':
+    flip = HorizontalFlip(p = 1)
+    crop = RandomCrop((321, 321))
+    rscales = RandomScale((0.75, 1.0, 1.5, 1.75, 2.0))
+    img = Image.open('data/img.jpg')
+    lb = Image.open('data/label.png')

flask_GAN/app.py

@@ -0,0 +1,294 @@
+# app.py
+# -*- coding: utf-8 -*-
+import os, sys, io, uuid, time, traceback
+from typing import Optional
+from PIL import Image
+
+from flask import Flask, request, jsonify, render_template_string, send_from_directory
+from werkzeug.utils import secure_filename
+
+import torch
+import torch.nn as nn
+import torchvision.transforms as T
+
+from typing import Optional
+
+# ========= 你训练仓库的路径：改成你的实际路径 =========
+PIX2PIX_ROOT = "/Users/liutao/Downloads/python/pix2pix_local"
+sys.path.insert(0, PIX2PIX_ROOT)
+
+# 从你的训练仓库导入“网络构造函数”
+# 官方实现一般是 models/networks.py 里提供 define_G
+from models.networks import define_G
+
+# ---------------- 基本配置 ----------------
+WEIGHTS_PATH = "./weights/150_net_G.pth"   # 你的权重
+UPLOAD_DIR   = "./runtime/uploads"
+OUTPUT_DIR   = "./runtime/outputs"
+os.makedirs(UPLOAD_DIR, exist_ok=True)
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+IMG_H, IMG_W = 1536, 512
+NORM_TO_MINUS1_1 = True   # Pix2Pix 通常使用 [-1,1] 归一化
+
+# ---------------- Flask ----------------
+app = Flask(__name__)
+
+# 放在 app = Flask(__name__) 下面
+from flask_cors import CORS
+CORS(app, resources={r"/api/*": {"origins": "*"}}, supports_credentials=True)
+
+# 允许较大上传（比如 50MB）
+app.config["MAX_CONTENT_LENGTH"] = 50 * 1024 * 1024
+
+# 统一给响应加上允许头（有时浏览器仍会要）
+@app.after_request
+def add_cors_headers(resp):
+    resp.headers["Access-Control-Allow-Origin"] = "*"
+    resp.headers["Access-Control-Allow-Methods"] = "GET,POST,OPTIONS"
+    resp.headers["Access-Control-Allow-Headers"] = "Content-Type,Authorization"
+    return resp
+
+
+INDEX_HTML = r"""
+<!doctype html>
+<html lang="zh-CN">
+<head><meta charset="utf-8"/><meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>Pix2Pix 4通道推理 Demo</title>
+<style>
+  body {
+    font-family: system-ui;
+    max-width: 980px;
+    margin: 24px auto;
+  }
+  .card {
+    border: 1px solid #e5e7eb;
+    border-radius: 12px;
+    padding: 16px;
+    margin: 12px 0;
+  }
+  .btn {
+    padding: 10px 16px;
+    border-radius: 8px;
+    border: 1px solid #e5e7eb;
+    background: #10b981;
+    color: #fff;
+    cursor: pointer;
+  }
+  .mono {
+    font-family: ui-monospace, Menlo, Consolas, monospace;
+  }
+
+  /* ✅ 新增部分：限制结果图片的显示尺寸 */
+  #result img {
+    max-width: 128px;      /* 最大显示宽度为 512px */
+    max-height: 600px;     /* 超过则等比例缩放 */
+              /* 自适应容器宽度 */
+    height: auto;
+    border-radius: 8px;
+    border: 1px solid #e5e7eb;
+    display: block;
+    margin-top: 10px;
+  }
+
+  /* 可选：添加“查看原图”链接样式 */
+  .view-full {
+    display: inline-block;
+    margin-top: 8px;
+    color: #2563eb;
+    font-size: 14px;
+  }
+</style>
+</head>
+<body>
+<h2>Pix2Pix 4通道（RGB+黑mask, 512×1536）在线推理</h2>
+
+<div class="card">
+  <p>当前权重：<code id="w"></code></p>
+  <p>上传一张图片（将被缩放到 512×1536，并在后端叠加全黑 mask 作为第4通道）：</p>
+  <input id="img" type="file" accept="image/*"/>
+  <button id="run" class="btn">生成</button>
+  <span id="s" class="mono"></span>
+</div>
+
+<div class="card">
+  <h3>输出</h3>
+  <div id="out"></div>
+</div>
+
+<script>
+async function postForm(url, formData){
+  const r = await fetch(url, {method:"POST", body:formData});
+  if(!r.ok) throw new Error("HTTP "+r.status);
+  return await r.json();
+}
+document.getElementById("w").textContent = "{{ weight_name }}";
+document.getElementById("run").onclick = async ()=>{
+  const s = document.getElementById("s");
+  const out = document.getElementById("out");
+  out.innerHTML = "";
+  const f = document.getElementById("img").files[0];
+  if(!f){ s.textContent = "请先选择图片"; return; }
+  s.textContent = "推理中...";
+  const fd = new FormData();
+  fd.append("image", f);
+  try{
+    const j = await postForm("/api/predict", fd);
+    s.textContent = "耗时 "+j.latency_ms+" ms";
+    const img = document.createElement("img");
+    img.src = j.output_url+"?t="+Date.now();
+    img.style.maxWidth = "100%";
+    out.appendChild(img);
+  }catch(e){
+    s.textContent = "失败："+e.message;
+  }
+};
+</script>
+</body></html>
+"""
+
+# ---------------- 模型加载（关键） ----------------
+NETG: Optional[nn.Module] = None
+
+def build_netG() -> nn.Module:
+    """
+    复用你训练时的参数：
+      --netG unet_512 --norm instance --no_dropout
+      且你是 4通道输入（RGB+mask），3通道输出
+    官方实现 define_G 的典型签名：
+      define_G(input_nc, output_nc, ngf=64, netG='unet_256', norm='batch', use_dropout=False, init_type='normal', init_gain=0.02, gpu_ids=[])
+    """
+    netG = define_G(
+        input_nc=4,           # 你的输入 RGB+mask = 4
+        output_nc=3,          # 输出 RGB = 3
+        ngf=64,
+        netG='unet_512',      # 训练用的 unet_512
+        norm='instance',      # 训练用的 instance
+        use_dropout=False     # 训练时 --no_dropout
+    )
+    return netG
+
+def load_weights_into(net: nn.Module, weight_path: str):
+    state = torch.load(weight_path, map_location="cpu")
+    # 有些保存方式会套一层
+    for key in ["state_dict", "netG", "model", "module"]:
+        if isinstance(state, dict) and key in state and isinstance(state[key], (dict, torch.nn.modules.module.Module)):
+            # 常见：{'state_dict': {...}} 或 {'netG': state_dict}
+            state = state[key]
+            break
+    # 如果键名带 'module.' 前缀，去掉
+    if isinstance(state, dict):
+        new_state = {}
+        for k, v in state.items():
+            nk = k.replace("module.", "")  # DataParallel 保存会多这个前缀
+            new_state[nk] = v
+        state = new_state
+    missing, unexpected = net.load_state_dict(state, strict=False)
+    print(f"[load_state_dict] missing: {missing}, unexpected: {unexpected}")
+
+def init_model():
+    global NETG
+    netG = build_netG()
+    load_weights_into(netG, WEIGHTS_PATH)
+    netG.eval().to(DEVICE)
+    NETG = netG
+    print(f"[OK] netG loaded on {DEVICE} from {WEIGHTS_PATH}")
+
+# ---------------- 预处理/后处理 ----------------
+def pil_to_tensor_4ch(img: Image.Image, mask_img: Optional[Image.Image] = None) -> torch.Tensor:
+    # 1) 尺寸对齐：只有不一致才调整
+    img = img.convert("RGB")
+    if img.size != (IMG_W, IMG_H):
+        # 你的数据就是 512x1536；不一致时才处理：等比按高缩放，再左裁/右补到 512
+        new_w = round(img.width * IMG_H / img.height)
+        img = img.resize((new_w, IMG_H), Image.BICUBIC)
+        if new_w >= IMG_W:
+            img = img.crop((0, 0, IMG_W, IMG_H))
+        else:
+            pad = Image.new("RGB", (IMG_W, IMG_H), (0,0,0))
+            pad.paste(img, (0,0))
+            img = pad
+
+    if mask_img is not None:
+        mask_img = mask_img.convert("L")
+        if mask_img.size != (IMG_W, IMG_H):
+            # 对 mask 只能用最近邻，避免灰边
+            new_w = round(mask_img.width * IMG_H / mask_img.height)
+            mask_img = mask_img.resize((new_w, IMG_H), Image.NEAREST)
+            if new_w >= IMG_W:
+                mask_img = mask_img.crop((0, 0, IMG_W, IMG_H))
+            else:
+                padm = Image.new("L", (IMG_W, IMG_H), 0)
+                padm.paste(mask_img, (0,0))
+                mask_img = padm
+        m = T.ToTensor()(mask_img)   # [1,H,W], 值∈[0,1]
+    else:
+        m = torch.zeros(1, IMG_H, IMG_W)
+
+    # 2) 与 test.py 同分布：ToTensor->[0,1] 再 *2-1
+    x3 = T.ToTensor()(img)           # [3,H,W], [0,1]
+    x3 = x3 * 2.0 - 1.0              # [-1,1] 等价于 Normalize(0.5,0.5)
+
+    x4 = torch.cat([x3, m], dim=0)   # [4,H,W]
+    return x4
+
+def tensor_to_pil(y: torch.Tensor) -> Image.Image:
+    if y.dim() == 4:
+        y = y[0]
+    y = y.detach().cpu()
+    if NORM_TO_MINUS1_1:
+        y = (y.clamp(-1,1) + 1.0)/2.0
+    else:
+        y = y.clamp(0,1)
+    y = (y*255.0).byte().numpy().transpose(1,2,0)
+    return Image.fromarray(y, mode="RGB")
+
+# ---------------- 路由 ----------------
+@app.route("/", methods=["GET"])
+def home():
+    return render_template_string(INDEX_HTML, weight_name=os.path.basename(WEIGHTS_PATH))
+
+@app.route("/api/predict", methods=["OPTIONS"])
+def predict_preflight():
+    return ("", 204)
+
+import time, uuid, os
+@app.route("/api/predict", methods=["POST"])
+@torch.no_grad()
+def predict():
+    app.logger.info("== /api/predict called at %s ==", time.time())
+    if NETG is None:
+        return jsonify({"ok": False, "error": "model not ready"}), 500
+    f = request.files.get("image")
+    if not f:
+        return jsonify({"ok": False, "error": "no image"}), 400
+    fname = secure_filename(f.filename or f"{uuid.uuid4().hex}.png")
+    inpath = os.path.join(UPLOAD_DIR, fname)
+    f.save(inpath)
+
+    img = Image.open(inpath)
+    x = pil_to_tensor_4ch(img, mask_img=None).unsqueeze(0).to(DEVICE)  # [1,4,H,W]
+    t0 = time.time()
+    y = NETG(x)               # 期待 [1,3,H,W]
+    latency = int((time.time() - t0)*1000)
+    out_img = tensor_to_pil(y)
+    out_name = f"{uuid.uuid4().hex}.png"
+    out_path = os.path.join(OUTPUT_DIR, out_name)
+    out_img.save(out_path)
+    return jsonify({"ok": True, "latency_ms": latency, "output_url": f"/outputs/{out_name}"})
+
+@app.route("/outputs/<path:name>")
+def outputs(name):
+    return send_from_directory(OUTPUT_DIR, name)
+
+# ---------------- 主入口 ----------------
+if __name__ == "__main__":
+    print(f"Device: {DEVICE}")
+    init_model()
+    app.run(host="127.0.0.1", port=5000, debug=True)
+
+@app.errorhandler(403)
+def handle_403(e):
+    app.logger.warning("403 Forbidden: %s", repr(e))
+    return jsonify({"ok": False, "error": "forbidden", "detail": str(e)}), 403

flask_GAN/app_auto_mask.py

@@ -0,0 +1,306 @@
+# app_auto_mask.py
+# -*- coding: utf-8 -*-
+import os, sys, io, uuid, time
+from pathlib import Path
+from typing import Optional
+from PIL import Image
+
+from flask import Flask, request, jsonify, render_template_string, send_from_directory
+from flask_cors import CORS
+from werkzeug.utils import secure_filename
+
+import torch
+import torch.nn as nn
+import torchvision.transforms as T
+# ========== Paths ==========
+from pathlib import Path
+
+# 以当前 app_auto_mask.py 所在目录为基准
+THIS_DIR = Path(__file__).resolve().parent
+PROJECT_ROOT = THIS_DIR.parent   # 就是 Nose Generation 这个目录
+
+# 1) pix2pix repo
+PIX2PIX_ROOT = PROJECT_ROOT / "pix2pix_vgg"
+sys.path.insert(0, str(PIX2PIX_ROOT))
+from models.networks import define_G
+
+# 2) face_parsing repo  （确认文件夹名字是 face_parsing-main 还是 face_parsing_main）
+FACE_PARSING_ROOT = PROJECT_ROOT / "face_parsing-main"
+sys.path.insert(0, str(FACE_PARSING_ROOT))
+from test_nose_mask_single import make_nose_mask_pil
+from softmask import make_softmask_pil
+
+FP_WEIGHTS   = FACE_PARSING_ROOT / "fp_512.pth"
+INFERENCE_PY = FACE_PARSING_ROOT / "inference.py"
+
+
+# ========== Runtime & constants ==========
+WEIGHTS_PATH = "./weights/245_net_G.pth"
+RUNTIME_DIR  = Path("./runtime")
+UPLOAD_DIR   = RUNTIME_DIR / "uploads"
+OUTPUT_DIR   = RUNTIME_DIR / "outputs"
+for d in (RUNTIME_DIR, UPLOAD_DIR, OUTPUT_DIR):
+    d.mkdir(parents=True, exist_ok=True)
+
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+IMG_W, IMG_H = 512, 1536     # (width, height)
+NORM_TO_MINUS1_1 = True
+
+# ========== Flask ==========
+app = Flask(__name__)
+CORS(app, resources={r"/api/*": {"origins": "*"}}, supports_credentials=True)
+app.config["MAX_CONTENT_LENGTH"] = 50 * 1024 * 1024
+
+@app.after_request
+def add_cors_headers(resp):
+    resp.headers["Access-Control-Allow-Origin"] = "*"
+    resp.headers["Access-Control-Allow-Methods"] = "GET,POST,OPTIONS"
+    resp.headers["Access-Control-Allow-Headers"] = "Content-Type,Authorization"
+    return resp
+
+INDEX_HTML = r"""
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8"/><meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>Pix2Pix (Auto Nose Mask, 512×1536) – Online Inference</title>
+<style>
+  :root{--card:#e5e7eb}
+  body{font-family:system-ui, -apple-system, Segoe UI, Roboto;max-width:1100px;margin:24px auto;padding:0 12px}
+  h2{margin:8px 0 16px}
+  .card{border:1px solid var(--card);border-radius:12px;padding:16px;margin:12px 0}
+  .btn{padding:10px 16px;border-radius:8px;border:1px solid var(--card);background:#10b981;color:#fff;cursor:pointer}
+  .mono{font-family:ui-monospace, Menlo, Consolas, monospace}
+  .grid{display:grid;grid-template-columns:1fr 1fr;gap:16px;align-items:start}
+  .pane h3{margin:0 0 8px}
+  img.result-img{max-width:min(512px, 44vw);max-height:80vh;width:auto;height:auto;display:block;border:1px solid var(--card);border-radius:8px;margin-top:8px;background:#000}
+  .muted{color:#6b7280}
+  .inline{display:inline-block;margin-left:8px}
+</style>
+</head>
+<body>
+  <h2>Pix2Pix (Auto Nose Mask, 512×1536) – Online Inference</h2>
+
+  <div class="card">
+    <p>Current weights: <code>{{ weight_name }}</code></p>
+    <input id="img" type="file" accept="image/*"/>
+    <button id="run" class="btn">Run</button>
+    <span id="s" class="mono inline"></span>
+    <div class="muted" style="margin-top:6px">
+      The uploaded image is <b>fit inside 512×1536</b> (keep aspect ratio).  
+      We downscale only if needed; remaining area is padded with black. No second resize later.
+    </div>
+  </div>
+
+  <div class="card">
+    <div class="grid">
+      <div class="pane">
+        <h3>Input (aligned to 512×1536)</h3>
+        <img id="imgIn" class="result-img" alt="Aligned input will appear here"/>
+      </div>
+      <div class="pane">
+        <h3>Output</h3>
+        <img id="imgOut" class="result-img" alt="Model output will appear here"/>
+      </div>
+    </div>
+  </div>
+
+<script>
+async function postForm(url, fd){
+  const r = await fetch(url, {method:"POST", body:fd});
+  if(!r.ok) throw new Error("HTTP "+r.status);
+  return await r.json();
+}
+const elStatus = document.getElementById("s");
+const elIn  = document.getElementById("imgIn");
+const elOut = document.getElementById("imgOut");
+
+document.getElementById("run").onclick = async ()=>{
+  const f = document.getElementById("img").files[0];
+  if(!f){ elStatus.textContent = "Please choose an image."; return; }
+  elStatus.textContent = "Running...";
+  const fd = new FormData(); fd.append("image", f);
+  try{
+    const j = await postForm("/api/predict", fd);
+    elStatus.textContent = (j.used_mask ? "Auto mask ✓" : "No mask") + " | " + j.latency_ms + " ms";
+    if (j.input_url) elIn.src = j.input_url + "?t=" + Date.now();
+    if (j.output_url) elOut.src = j.output_url + "?t=" + Date.now();
+  }catch(e){
+    elStatus.textContent = "Failed: " + e.message;
+  }
+};
+</script>
+</body></html>
+"""
+
+# ========== Model loading ==========
+NETG: Optional[nn.Module] = None
+
+def build_netG() -> nn.Module:
+    return define_G(
+        input_nc=4, output_nc=3, ngf=64,
+        netG='unet_512', norm='instance', use_dropout=False
+    )
+
+def load_weights_into(net: nn.Module, weight_path: str):
+    state = torch.load(weight_path, map_location="cpu")
+    if isinstance(state, dict) and "state_dict" in state:
+        state = state["state_dict"]
+    state = {k.replace("module.", ""): v for k, v in state.items()}
+    missing, unexpected = net.load_state_dict(state, strict=False)
+    print(f"[load_state_dict] missing: {missing}, unexpected: {unexpected}")
+
+def init_model():
+    global NETG
+    net = build_netG()
+    load_weights_into(net, WEIGHTS_PATH)
+    net.eval().to(DEVICE)
+    NETG = net
+    print(f"[OK] netG loaded on {DEVICE} from {WEIGHTS_PATH}")
+
+# ========== Pre/Post ==========
+def fit_inside_and_pad(img: Image.Image, W: int, H: int, pad_color=(40,40,40)) -> Image.Image:
+    """
+    Keep aspect ratio:
+      - If either side > target -> scale down by min(W/w, H/h).
+      - If both sides <= target -> keep size (no upscaling).
+    Then pad to (W,H) with pad_color. Paste at (0,0).
+    Only one interpolation (BICUBIC) happens here.
+    """
+    img = img.convert("RGB")
+    w, h = img.size
+    if w > W or h > H:
+        s = min(W / w, H / h)
+        new_w = max(1, int(round(w * s)))
+        new_h = max(1, int(round(h * s)))
+        img = img.resize((new_w, new_h), Image.BICUBIC)
+    canvas = Image.new("RGB", (W, H), pad_color)
+    canvas.paste(img, (0, 0))
+    return canvas
+
+def align_img(img: Image.Image) -> Image.Image:
+    return fit_inside_and_pad(img, IMG_W, IMG_H, pad_color=(40,40,40))
+
+def ensure_mask_same_size(mask: Image.Image) -> Image.Image:
+    """
+    Expect mask already 512×1536. If not, do a single NEAREST correction.
+    Then binarize to {0,255}.
+    """
+    mask = mask.convert("L")
+    if mask.size != (IMG_W, IMG_H):
+        # Single correction only if mismatch (rare)
+        w, h = mask.size
+        s = min(IMG_W / w, IMG_H / h)
+        new_w = max(1, int(round(w * s)))
+        new_h = max(1, int(round(h * s)))
+        mask = mask.resize((new_w, new_h), Image.NEAREST)
+        canvas = Image.new("L", (IMG_W, IMG_H), 0)
+        canvas.paste(mask, (0, 0))
+        mask = canvas
+    # binarize
+    mask = mask.point(lambda p: 255 if p > 127 else 0, mode="L")
+    return mask
+
+def pil_to_tensor_4ch(img_aligned: Image.Image, mask_img: Optional[Image.Image]) -> torch.Tensor:
+    """
+    img_aligned must already be 512×1536.
+    mask_img should be same size; we only binarize -> [0,1], no resize.
+    """
+    assert img_aligned.size == (IMG_W, IMG_H)
+    x3 = T.ToTensor()(img_aligned)              # [0,1]
+    if NORM_TO_MINUS1_1: x3 = x3 * 2 - 1        # [-1,1]
+
+    if mask_img is not None:
+        mask_fixed = ensure_mask_same_size(mask_img)
+        m = T.ToTensor()(mask_fixed)            # [1,H,W], in [0,1]
+        # Explicitly clamp to {0,1} to avoid gray
+        m = (m > 0.5).float()
+        x4 = torch.cat([x3, m], dim=0)
+    else:
+        x4 = torch.cat([x3, torch.zeros(1, IMG_H, IMG_W)], dim=0)
+    return x4
+
+def tensor_to_pil(y: torch.Tensor) -> Image.Image:
+    if y.dim() == 4: y = y[0]
+    y = y.detach().cpu().clamp(-1,1)
+    y = (y + 1)/2
+    y = (y*255).byte().numpy().transpose(1,2,0)
+    return Image.fromarray(y, "RGB")
+
+# ========== Routes ==========
+@app.route("/", methods=["GET"])
+def home():
+    return render_template_string(INDEX_HTML, weight_name=os.path.basename(WEIGHTS_PATH))
+
+@app.route("/outputs/<path:name>")
+def outputs(name):
+    return send_from_directory(str(OUTPUT_DIR), name)
+
+@app.route("/api/predict", methods=["OPTIONS"])
+def predict_preflight():
+    return ("", 204)
+
+@app.route("/api/predict", methods=["POST"])
+@torch.no_grad()
+def predict():
+    if NETG is None:
+        return jsonify({"ok": False, "error": "model not ready"}), 500
+
+    f = request.files.get("image")
+    if not f:
+        return jsonify({"ok": False, "error": "no image"}), 400
+
+    # 1) read & align ONCE
+    raw_name = f.filename or f"{uuid.uuid4().hex}.png"
+    _ = secure_filename(raw_name)
+    img_raw = Image.open(io.BytesIO(f.read())).convert("RGB")
+    img_aligned = align_img(img_raw)
+
+    # save aligned input as PNG (avoid JPEG blur)
+    in_name = f"in_{uuid.uuid4().hex}.png"
+    in_path = OUTPUT_DIR / in_name
+    img_aligned.save(in_path, format="PNG")
+
+    # 2) generate mask on the aligned image
+    try:
+        mask_img = make_softmask_pil(
+            img=img_aligned,              # EXACTLY 512×1536
+            weights=FP_WEIGHTS,
+            inference_fp=INFERENCE_PY,
+            device="cpu",                 # change to "cuda:0" if available
+            y_top=400,
+            sigma=4.0,
+            nose_id=10,
+        )
+        used_mask = True
+    except Exception as e:
+        print("[mask] generation failed:", e)
+        mask_img = None
+        used_mask = False
+
+    # 3) inference (no more resizing)
+    x = pil_to_tensor_4ch(img_aligned, mask_img=mask_img).unsqueeze(0).to(DEVICE)
+    t0 = time.time()
+    y = NETG(x)
+    latency = int((time.time() - t0) * 1000)
+
+    out_img = tensor_to_pil(y)
+    out_name = f"out_{uuid.uuid4().hex}.png"
+    out_img.save(OUTPUT_DIR / out_name, format="PNG")
+
+    return jsonify({
+        "ok": True,
+        "used_mask": used_mask,
+        "latency_ms": latency,
+        "input_url":  f"/outputs/{in_name}",
+        "output_url": f"/outputs/{out_name}",
+    })
+
+# ========== Entry ==========
+if __name__ == "__main__":
+    print("Device:", DEVICE)
+    for p in [PIX2PIX_ROOT, FACE_PARSING_ROOT, FP_WEIGHTS, INFERENCE_PY]:
+        print("[check]", p, "=>", p.exists())
+    init_model()
+    port = int(os.environ.get("PORT", 7860))
+    app.run(host="0.0.0.0", port=port, debug=False)

flask_GAN/app_mask.py

@@ -0,0 +1,258 @@
+# app_mask.py
+# -*- coding: utf-8 -*-
+import os, sys, io, uuid, time, re, unicodedata, traceback
+from typing import Optional
+from PIL import Image
+
+from flask import Flask, request, jsonify, render_template_string, send_from_directory
+from flask_cors import CORS
+from werkzeug.utils import secure_filename
+
+import torch
+import torch.nn as nn
+import torchvision.transforms as T
+
+# ========= 1) 指定你的 pix2pix 仓库路径（按实际修改） =========
+home = os.path.expanduser("~")
+PIX2PIX_ROOT = os.path.join(home, "Downloads", "python", "pix2pix_local")  # ← 改成你的路径
+sys.path.insert(0, PIX2PIX_ROOT)
+from models.networks import define_G  # 来自你的训练仓库
+
+# ========= 2) 目录/常量配置 =========
+WEIGHTS_PATH = "./weights/150_net_G.pth"
+UPLOAD_DIR   = "./runtime/uploads"
+OUTPUT_DIR   = "./runtime/outputs"
+MASK_DIR     = "./mask"                        # 掩码目录（同名匹配）
+os.makedirs(UPLOAD_DIR, exist_ok=True)
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+IMG_H, IMG_W = 1536, 512                      # 高、宽（注意顺序）
+NORM_TO_MINUS1_1 = True
+
+# ========= 3) Flask 基础 =========
+app = Flask(__name__)
+CORS(app, resources={r"/api/*": {"origins": "*"}}, supports_credentials=True)
+app.config["MAX_CONTENT_LENGTH"] = 50 * 1024 * 1024  # 50MB
+
+@app.after_request
+def add_cors_headers(resp):
+    resp.headers["Access-Control-Allow-Origin"] = "*"
+    resp.headers["Access-Control-Allow-Methods"] = "GET,POST,OPTIONS"
+    resp.headers["Access-Control-Allow-Headers"] = "Content-Type,Authorization"
+    return resp
+
+INDEX_HTML = r"""
+<!doctype html>
+<html lang="zh-CN">
+<head>
+<meta charset="utf-8"/><meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>Pix2Pix（RGB + 同名掩码，512×1536）</title>
+<style>
+  body{font-family:system-ui;max-width:980px;margin:24px auto}
+  .card{border:1px solid #e5e7eb;border-radius:12px;padding:16px;margin:12px 0}
+  .btn{padding:10px 16px;border-radius:8px;border:1px solid #e5e7eb;background:#10b981;color:#fff;cursor:pointer}
+  .mono{font-family:ui-monospace,Menlo,Consolas,monospace}
+  #result{max-width:540px}
+  img.result-img{max-width:min(512px,90vw);max-height:80vh;width:auto;height:auto;display:block;border:1px solid #e5e7eb;border-radius:8px;margin-top:10px}
+</style>
+</head>
+<body>
+<h2>Pix2Pix（RGB + mask, 512×1536）Online Testing</h2>
+<div class="card">
+  <p>Current weight:<code>{{ weight_name }}</code></p>
+  <p>Upload only pictures. The server will use<code>./mask/</code> contents to match mask（png/jpg/jpeg/bmp/webp/tif）。If found, it is used as the 4th channel; if not found, no mask is used.</p>
+  <input id="img" type="file" accept="image/*"/>
+  <button id="run" class="btn">Generate</button>
+  <span id="s" class="mono"></span>
+</div>
+<div class="card"><h3>output</h3><div id="result"></div></div>
+<script>
+async function postForm(url, fd){
+  const r = await fetch(url, {method:"POST", body:fd});
+  if(!r.ok) throw new Error("HTTP "+r.status);
+  return await r.json();
+}
+const result = document.getElementById("result");
+document.getElementById("run").onclick = async ()=>{
+  const s = document.getElementById("s");
+  const f = document.getElementById("img").files[0];
+  if(!f){ s.textContent = "please upload image"; return; }
+  s.textContent = "推理中...";
+  const fd = new FormData(); fd.append("image", f);
+  try{
+    const j = await postForm("/api/predict", fd);
+    s.textContent = (j.used_mask ? "use mask ✓" : "未使用掩码") + " ｜cost  " + j.latency_ms + " ms";
+    const img = document.createElement("img");
+    img.className = "result-img";
+    img.src = j.output_url + "?t=" + Date.now();
+    result.innerHTML = ""; result.appendChild(img);
+  }catch(e){
+    s.textContent = "失败：" + e.message;
+  }
+};
+</script>
+</body></html>
+"""
+
+# ========= 4) 模型加载 =========
+NETG: Optional[nn.Module] = None
+
+def build_netG() -> nn.Module:
+    # 与训练一致：unet_512 + instance + no_dropout，输入4/输出3
+    netG = define_G(
+        input_nc=4,
+        output_nc=3,
+        ngf=64,
+        netG='unet_512',
+        norm='instance',
+        use_dropout=False
+    )
+    return netG
+
+def load_weights_into(net: nn.Module, weight_path: str):
+    state = torch.load(weight_path, map_location="cpu")
+    if isinstance(state, dict) and "state_dict" in state:
+        state = state["state_dict"]
+    new_state = {k.replace("module.", ""): v for k, v in state.items()}
+    missing, unexpected = net.load_state_dict(new_state, strict=False)
+    print(f"[load_state_dict] missing: {missing}, unexpected: {unexpected}")
+
+def init_model():
+    global NETG
+    netG = build_netG()
+    load_weights_into(netG, WEIGHTS_PATH)
+    netG.eval().to(DEVICE)
+    NETG = netG
+    print(f"[OK] netG loaded on {DEVICE} from {WEIGHTS_PATH}")
+
+# ========= 5) 预处理 =========
+def align_img(img: Image.Image) -> Image.Image:
+    """高度对齐到 1536；��宽>=512取左侧512，否则右侧补黑到512。"""
+    img = img.convert("RGB")
+    if img.size == (IMG_W, IMG_H):
+        return img
+    new_w = round(img.width * IMG_H / img.height)
+    img = img.resize((new_w, IMG_H), Image.BICUBIC)
+    if new_w >= IMG_W:
+        return img.crop((0, 0, IMG_W, IMG_H))
+    pad = Image.new("RGB", (IMG_W, IMG_H), (0,0,0))
+    pad.paste(img, (0,0))
+    return pad
+
+def align_mask(mask: Image.Image) -> Image.Image:
+    """与图片同策略但用最近邻，避免灰边。"""
+    mask = mask.convert("L")
+    if mask.size == (IMG_W, IMG_H):
+        return mask
+    new_w = round(mask.width * IMG_H / mask.height)
+    mask = mask.resize((new_w, IMG_H), Image.NEAREST)
+    if new_w >= IMG_W:
+        return mask.crop((0, 0, IMG_W, IMG_H))
+    pad = Image.new("L", (IMG_W, IMG_H), 0)
+    pad.paste(mask, (0,0))
+    return pad
+
+def pil_to_tensor_4ch(img: Image.Image, mask_img: Optional[Image.Image]) -> torch.Tensor:
+    img = align_img(img)
+    x3  = T.ToTensor()(img)                 # [0,1]
+    if NORM_TO_MINUS1_1: x3 = x3 * 2 - 1    # [-1,1]
+    if mask_img is not None:
+        m  = T.ToTensor()(align_mask(mask_img))  # [1,H,W] ∈ [0,1]
+        x4 = torch.cat([x3, m], dim=0)
+    else:
+        # 不使用掩码：仍然保持 4 通道（最后一通道为 0）
+        x4 = torch.cat([x3, torch.zeros(1, IMG_H, IMG_W)], dim=0)
+    return x4
+
+def tensor_to_pil(y: torch.Tensor) -> Image.Image:
+    if y.dim() == 4: y = y[0]
+    y = y.detach().cpu().clamp(-1,1)
+    y = (y + 1)/2
+    y = (y*255).byte().numpy().transpose(1,2,0)
+    return Image.fromarray(y, "RGB")
+
+# ========= 6) 掩码匹配（鲁棒） =========
+MASK_EXTS = [".png", ".jpg", ".jpeg", ".bmp", ".webp", ".tif", ".tiff"]
+
+def _norm_stem(s: str) -> str:
+    s = unicodedata.normalize("NFKD", s).lower()
+    return re.sub(r"[^a-z0-9]+", "", s)  # 仅保留字母数字
+
+def find_mask_by_stems(candidates: list[str]) -> Optional[str]:
+    norm_targets = {_norm_stem(st) for st in candidates if st}
+    print("[MASK] target stems:", candidates, "=>", list(norm_targets))
+    try:
+        for name in os.listdir(MASK_DIR):
+            p = os.path.join(MASK_DIR, name)
+            if not os.path.isfile(p):
+                continue
+            stem, ext = os.path.splitext(name)
+            if ext.lower() not in MASK_EXTS:
+                continue
+            if _norm_stem(stem) in norm_targets:
+                print(f"[MASK] matched: {name}")
+                return p
+    except FileNotFoundError:
+        print("[MASK] MASK_DIR not found:", MASK_DIR)
+    print("[MASK] no match in:", MASK_DIR)
+    return None
+
+# ========= 7) 路由 =========
+@app.route("/", methods=["GET"])
+def home():
+    return render_template_string(INDEX_HTML, weight_name=os.path.basename(WEIGHTS_PATH))
+
+@app.route("/outputs/<path:name>")
+def outputs(name):
+    return send_from_directory(OUTPUT_DIR, name)
+
+@app.route("/api/predict", methods=["OPTIONS"])
+def predict_preflight():
+    return ("", 204)
+
+@app.route("/api/predict", methods=["POST"])
+@torch.no_grad()
+def predict():
+    if NETG is None:
+        return jsonify({"ok": False, "error": "model not ready"}), 500
+
+    f = request.files.get("image")
+    if not f:
+        return jsonify({"ok": False, "error": "no image"}), 400
+
+    raw_name = f.filename or f"{uuid.uuid4().hex}.png"   # 原始文件名
+    safe_name = secure_filename(raw_name)                # 安全化后
+    stem_raw, _    = os.path.splitext(raw_name)
+    stem_safe, _   = os.path.splitext(safe_name)
+
+    # 读图
+    img_bytes = f.read()
+    img = Image.open(io.BytesIO(img_bytes))
+
+    # 匹配掩码
+    mask_path = find_mask_by_stems([stem_raw, stem_safe])
+    mask_img  = Image.open(mask_path) if mask_path else None
+    used_mask = bool(mask_img)
+
+    # 预处理 & 推理
+    x = pil_to_tensor_4ch(img, mask_img=mask_img).unsqueeze(0).to(DEVICE)
+    t0 = time.time()
+    y = NETG(x)
+    latency = int((time.time() - t0) * 1000)
+
+    # 保存输出
+    out_img = tensor_to_pil(y)
+    out_name = f"{uuid.uuid4().hex}.png"
+    out_path = os.path.join(OUTPUT_DIR, out_name)
+    out_img.save(out_path)
+
+    return jsonify({"ok": True, "used_mask": used_mask, "latency_ms": latency,
+                    "output_url": f"/outputs/{out_name}"})
+
+# ========= 8) 入口 =========
+if __name__ == "__main__":
+    print("Device:", DEVICE)
+    init_model()
+    # 为避免与你原来的 app 冲突，这里用 5001；需要可改回 5000
+    app.run(host="127.0.0.1", port=5001, debug=True)

flask_GAN/resize.py

@@ -0,0 +1,40 @@
+# crop_left_512.py
+import os
+from PIL import Image
+
+INPUT_DIR  = "./picture"          # 原图文件夹
+OUTPUT_DIR = "./picture_resized"  # 输出文件夹
+TARGET_H   = 1536                 # 目标高度（像素）
+CROP_W     = 512                  # 只保留左侧 [0, 512) 宽度
+
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+def is_img(name):
+    return name.lower().endswith((".jpg", ".jpeg", ".png", ".bmp", ".webp", ".tif", ".tiff"))
+
+for fname in os.listdir(INPUT_DIR):
+    if not is_img(fname):
+        continue
+    src = os.path.join(INPUT_DIR, fname)
+    dst = os.path.join(OUTPUT_DIR, fname)
+    try:
+        with Image.open(src) as im:
+            im = im.convert("RGB")
+
+            # 1) 若高度不是 1536，先按比例把高度调整到 1536（宽度等比变化）
+            if im.height != TARGET_H:
+                new_w = round(im.width * TARGET_H / im.height)
+                im = im.resize((new_w, TARGET_H), Image.BICUBIC)
+
+            # 2) 若宽度不足 512，跳过并提示；否则裁剪左侧 0~512 宽度
+            if im.width < CROP_W:
+                print(f"[SKIP] {fname}: width {im.width} < {CROP_W}")
+                continue
+
+            left_crop = im.crop((0, 0, CROP_W, TARGET_H))  # (left, top, right, bottom)
+            left_crop.save(dst)
+            print(f"[OK] {fname} -> {dst}")
+    except Exception as e:
+        print(f"[ERR] {fname}: {e}")
+
+print("✅ 完成：已将左侧 0-512 宽度裁剪并输出到", OUTPUT_DIR)