facechain root directory upload

facechain/.gitattributes

@@ -0,0 +1 @@
+*.safetensors filter=lfs diff=lfs merge=lfs -text

facechain/.gitignore

@@ -0,0 +1,134 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+test.py
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+/package
+/temp
+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/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# 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/
+
+.vscode
+.idea
+
+# custom
+*.pkl
+*.pkl.json
+*.log.json
+*.whl
+*.tar.gz
+*.swp
+*.log
+*.tar.gz
+source.sh
+tensorboard.sh
+.DS_Store
+replace.sh
+result.png
+lora_result.png
+result.jpg
+result.mp4
+
+# Pytorch
+*.pth
+*.pt
+
+# ast template
+ast_index_file.py

facechain/LICENSE

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

facechain/README.md

@@ -0,0 +1,296 @@
+<p align="center">
+    <br>
+    <img src="https://modelscope.oss-cn-beijing.aliyuncs.com/modelscope.gif" width="400"/>
+    <br>
+    <h1>FaceChain</h1>
+<p>
+
+# Introduction
+
+如果您熟悉中文，可以阅读[中文版本的README](./README_ZH.md)。
+
+FaceChain is a deep-learning toolchain for generating your Digital-Twin. With a minimum of 1 portrait-photo, you can create a Digital-Twin of your own and start generating personal portraits in different settings (multiple styles now supported!). You may train your Digital-Twin model and generate photos via FaceChain's Python scripts, or via the familiar Gradio interface.
+FaceChain is powered by [ModelScope](https://github.com/modelscope/modelscope).
+
+
+<p align="center">
+        ModelScope Studio <a href="https://modelscope.cn/studios/CVstudio/cv_human_portrait/summary">🤖<a></a>&nbsp ｜ HuggingFace Space <a href="https://huggingface.co/spaces/modelscope/FaceChain">🤗</a>&nbsp 
+</p>
+<br>
+
+
+![image](resources/git_cover.jpg)
+![image](resources/git_cover_1.jpg)
+![image](resources/git_cover_2.jpg)
+
+
+# News
+- High performance inpainting for single & double person, Simplify User Interface. (September 09th, 2023 UTC)
+- More Technology Details can be seen in [Paper](https://arxiv.org/abs/2308.14256). (August 30th, 2023 UTC)
+- Add validate & ensemble for Lora training, and InpaintTab(hide in gradio for now).  (August 28th, 2023 UTC)
+- Add pose control module.   (August 27th, 2023 UTC)
+- Add robust face lora training module, enhance the performance of one pic training & style-lora blending.   (August 27th, 2023 UTC)
+- HuggingFace Space is available now! You can experience FaceChain directly with <a href="https://huggingface.co/spaces/modelscope/FaceChain">🤗</a>      (August 25th, 2023 UTC)
+- Add awesome prompts! Refer to: [awesome-prompts-facechain](resources/awesome-prompts-facechain.txt)   (August 18th, 2023 UTC)
+- Support a series of new style models in a plug-and-play fashion.  (August 16th, 2023 UTC)
+- Support customizable prompts. (August 16th, 2023 UTC)
+- Colab notebook is available now! You can experience FaceChain directly with  [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/modelscope/facechain/blob/main/facechain_demo.ipynb).   (August 15th, 2023 UTC)
+
+
+# To-Do List
+- Support more style models (such as those on Civitai). --on-going, hot
+- Support more beauty-retouch effects
+- Support latest foundation models such as SDXL
+- Support high resolution
+- Support group photo scenario, e.g, multi-person
+- Provide more funny apps
+
+
+# Citation
+
+Please cite FaceChain in your publications if it helps your research
+```
+@article{liu2023facechain,
+  title={FaceChain: A Playground for Identity-Preserving Portrait Generation},
+  author={Liu, Yang and Yu, Cheng and Shang, Lei and Wu, Ziheng and 
+          Wang, Xingjun and Zhao, Yuze and Zhu, Lin and Cheng, Chen and 
+          Chen, Weitao and Xu, Chao and Xie, Haoyu and Yao, Yuan and 
+          Zhou,  Wenmeng and Chen Yingda and Xie, Xuansong and Sun, Baigui},
+  journal={arXiv preprint arXiv:2308.14256},
+  year={2023}
+}
+```
+
+
+# Installation
+
+## Compatibility Verification
+We have verified e2e execution on the following environment:
+- python: py3.8, py3.10
+- pytorch: torch2.0.0, torch2.0.1
+- tensorflow: 2.8.0, tensorflow-cpu
+- CUDA: 11.7
+- CUDNN: 8+
+- OS: Ubuntu 20.04, CentOS 7.9
+- GPU: Nvidia-A10 24G
+
+## Resource Requirement
+- GPU: About 19G
+- Disk: About 50GB
+
+## Installation Guide
+The following installation methods are supported:
+
+
+### 1. ModelScope notebook【recommended】
+
+   The ModelScope Notebook offers a free-tier that allows ModelScope user to run the FaceChain application with minimum setup, refer to [ModelScope Notebook](https://modelscope.cn/my/mynotebook/preset)
+
+```shell
+# Step1: 我的notebook -> PAI-DSW -> GPU环境
+
+# Step2: Entry the Notebook cell，clone FaceChain from github:
+!GIT_LFS_SKIP_SMUDGE=1 git clone https://github.com/modelscope/facechain.git --depth 1
+
+# Step3: Change the working directory to facechain:
+import os
+os.chdir('/mnt/workspace/facechain')    # You may change to your own path
+print(os.getcwd())
+
+!pip3 install gradio
+!pip3 install controlnet_aux==0.0.6
+!pip3 install python-slugify
+!python3 app.py
+
+
+# Step4: click "public URL" or "local URL", upload your images to 
+# train your own model and then generate your digital twin.
+```
+   Alternatively, you may also purchase a [PAI-DSW](https://www.aliyun.com/activity/bigdata/pai/dsw) instance (using A10 resource), with the option of ModelScope image to run FaceChain following similar steps.
+
+
+### 2. Docker
+
+If you are familiar with using docker, we recommend to use this way:
+
+```shell
+# Step1: Prepare the environment with GPU on local or cloud, we recommend to use Alibaba Cloud ECS, refer to: https://www.aliyun.com/product/ecs
+
+# Step2: Download the docker image (for installing docker engine, refer to https://docs.docker.com/engine/install/）
+docker pull registry.cn-hangzhou.aliyuncs.com/modelscope-repo/modelscope:ubuntu20.04-cuda11.7.1-py38-torch2.0.1-tf1.15.5-1.8.0
+
+# Step3: run the docker container
+docker run -it --name facechain -p 7860:7860 --gpus all registry.cn-hangzhou.aliyuncs.com/modelscope-repo/modelscope:ubuntu20.04-cuda11.7.1-py38-torch2.0.1-tf1.15.5-1.8.0 /bin/bash
+(Note: you may need to install the nvidia-container-runtime, refer to https://github.com/NVIDIA/nvidia-container-runtime)
+
+# Step4: Install the gradio in the docker container:
+pip3 install gradio
+pip3 install controlnet_aux==0.0.6
+pip3 install python-slugify
+
+# Step5 clone facechain from github
+GIT_LFS_SKIP_SMUDGE=1 git clone https://github.com/modelscope/facechain.git --depth 1
+cd facechain
+python3 app.py
+# Note: FaceChain currently assume single-GPU, if your environment has multiple GPU, please use the following instead:
+# CUDA_VISIBLE_DEVICES=0 python3 app.py
+
+# Step6
+Run the app server: click "public URL" --> in the form of: https://xxx.gradio.live
+```
+
+### 3. Conda Virtual Environment
+
+Use the conda virtual environment, and refer to [Anaconda](https://docs.anaconda.com/anaconda/install/) to manage your dependencies. After installation, execute the following commands:
+(Note: mmcv has strict environment requirements and might not be compatible in some cases. It's recommended to use Docker.)
+
+```shell
+conda create -n facechain python=3.8    # Verified environments: 3.8 and 3.10
+conda activate facechain
+
+GIT_LFS_SKIP_SMUDGE=1 git clone https://github.com/modelscope/facechain.git --depth 1
+cd facechain
+
+pip3 install -r requirements.txt
+pip3 install -U openmim 
+mim install mmcv-full==1.7.0
+
+# Navigate to the facechain directory and run:
+python3 app.py
+# Note: FaceChain currently assume single-GPU, if your environment has multiple GPU, please use the following instead:
+# CUDA_VISIBLE_DEVICES=0 python3 app.py
+
+# Finally, click on the URL generated in the log to access the web page.
+```
+
+**Note**: After the app service is successfully launched, go to the URL in the log, enter the "Image Customization" tab, click "Select Image to Upload", and choose at least one image with a face. Then, click "Start Training" to begin model training. After the training is completed, there will be corresponding displays in the log. Afterwards, switch to the "Image Experience" tab and click "Start Inference" to generate your own digital image.
+
+*Note* For windows user, you should pay attention to following steps:
+```shell
+1. reinstall  package pytorch and numpy compatible with tensorflow
+2. install mmcv-full by pip: pip3 install mmcv-full
+```
+
+
+### 4. Colab notebook
+
+| Colab | Info
+| --- | --- |
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/modelscope/facechain/blob/main/facechain_demo.ipynb) | FaceChain Installation on Colab
+
+
+
+# Script Execution
+
+FaceChain supports direct training and inference in the python environment. Run the following command in the cloned folder to start training:
+
+```shell
+PYTHONPATH=. sh train_lora.sh "ly261666/cv_portrait_model" "v2.0" "film/film" "./imgs" "./processed" "./output"
+```
+
+Parameters description:
+
+```text
+ly261666/cv_portrait_model: The stable diffusion base model of the ModelScope model hub, which will be used for training, no need to be changed.
+v2.0: The version number of this base model, no need to be changed
+film/film: This base model may contains multiple subdirectories of different styles, currently we use film/film, no need to be changed
+./imgs: This parameter needs to be replaced with the actual value. It means a local file directory that contains the original photos used for training and generation
+./processed: The folder of the processed images after preprocessing, this parameter needs to be passed the same value in inference, no need to be changed
+./output: The folder where the model weights stored after training, no need to be changed
+```
+
+Wait for 5-20 minutes to complete the training. Users can also adjust other training hyperparameters. The hyperparameters supported by training can be viewed in the file of `train_lora.sh`, or the complete hyperparameter list in `facechain/train_text_to_image_lora.py`.
+
+When inferring, please edit the code in run_inference.py:
+
+```python
+# Use depth control, default False, only effective when using pose control
+use_depth_control = False
+# Use pose control, default False
+use_pose_model = False
+# The path of the image for pose control, only effective when using pose control
+pose_image = 'poses/man/pose1.png'
+# Fill in the folder of the images after preprocessing above, it should be the same as during training
+processed_dir = './processed'
+# The number of images to generate in inference
+num_generate = 5
+# The stable diffusion base model used in training, no need to be changed
+base_model = 'ly261666/cv_portrait_model'
+# The version number of this base model, no need to be changed
+revision = 'v2.0'
+# This base model may contains multiple subdirectories of different styles, currently we use film/film, no need to be changed
+base_model_sub_dir = 'film/film'
+# The folder where the model weights stored after training, it must be the same as during training
+train_output_dir = './output'
+# Specify a folder to save the generated images, this parameter can be modified as needed
+output_dir = './generated'
+# Use Chinese style model, default False
+use_style = False
+```
+
+Then execute:
+
+```shell
+python run_inference.py
+```
+
+You can find the generated personal digital image photos in the `output_dir`.
+
+# Algorithm Introduction
+
+## Architectural Overview
+
+The ability of the personal portrait generation evolves around the text-to-image capability of Stable Diffusion model. We consider the main factors that affect the generation effect of personal portraits: portrait style information and user character information. For this, we use the style LoRA model trained offline and the face LoRA model trained online to learn the above information. LoRA is a fine-tuning model with fewer trainable parameters. In Stable Diffusion, the information of the input image can be injected into the LoRA model by the way of text generation image training with a small amount of input image. Therefore, the ability of the personal portrait model is divided into training and inference stages. The training stage generates image and text label data for fine-tuning the Stable Diffusion model, and obtains the face LoRA model. The inference stage generates personal portrait images based on the face LoRA model and style LoRA model.
+
+![image](resources/framework_eng.jpg)
+
+## Training
+
+Input: User-uploaded images that contain clear face areas
+
+Output: Face LoRA model
+
+Description: First, we process the user-uploaded images using an image rotation model based on orientation judgment and a face refinement rotation method based on face detection and keypoint models, and obtain images containing forward faces. Next, we use a human body parsing model and a human portrait beautification model to obtain high-quality face training images. Afterwards, we use a face attribute model and a text annotation model, combined with tag post-processing methods, to generate fine-grained labels for training images. Finally, we use the above images and label data to fine-tune the Stable Diffusion model to obtain the face LoRA model.
+
+## Inference
+
+Input: User-uploaded images in the training phase, preset input prompt words for generating personal portraits
+
+Output: Personal portrait image
+
+Description: First, we fuse the weights of the face LoRA model and style LoRA model into the Stable Diffusion model. Next, we use the text generation image function of the Stable Diffusion model to preliminarily generate personal portrait images based on the preset input prompt words. Then we further improve the face details of the above portrait image using the face fusion model. The template face used for fusion is selected from the training images through the face quality evaluation model. Finally, we use the face recognition model to calculate the similarity between the generated portrait image and the template face, and use this to sort the portrait images, and output the personal portrait image that ranks first as the final output result.
+
+## Model List
+
+The models used in FaceChain:
+
+[1]  Face detection model DamoFD：https://modelscope.cn/models/damo/cv_ddsar_face-detection_iclr23-damofd
+
+[2]  Image rotating model, offered in the ModelScope studio
+
+[3]  Human parsing model M2FP：https://modelscope.cn/models/damo/cv_resnet101_image-multiple-human-parsing
+
+[4]  Skin retouching model ABPN：https://www.modelscope.cn/models/damo/cv_unet_skin_retouching_torch
+
+[5]  Face attribute recognition model FairFace：https://modelscope.cn/models/damo/cv_resnet34_face-attribute-recognition_fairface
+
+[6]  DeepDanbooru model：https://github.com/KichangKim/DeepDanbooru
+
+[7]  Face quality assessment FQA：https://modelscope.cn/models/damo/cv_manual_face-quality-assessment_fqa
+
+[8]  Face fusion model：https://www.modelscope.cn/models/damo/cv_unet_face_fusion_torch
+
+[9]  Face recognition model RTS：https://modelscope.cn/models/damo/cv_ir_face-recognition-ood_rts          
+
+# More Information
+
+- [ModelScope library](https://github.com/modelscope/modelscope/)
+
+
+​		ModelScope Library provides the foundation for building the model-ecosystem of ModelScope, including the interface and implementation to integrate various models into ModelScope. 
+
+- [Contribute models to ModelScope](https://modelscope.cn/docs/ModelScope%E6%A8%A1%E5%9E%8B%E6%8E%A5%E5%85%A5%E6%B5%81%E7%A8%8B%E6%A6%82%E8%A7%88)
+
+# License
+
+This project is licensed under the [Apache License (Version 2.0)](https://github.com/modelscope/modelscope/blob/master/LICENSE).

facechain/README_ZH.md

@@ -0,0 +1,297 @@
+<p align="center">
+    <br>
+    <img src="https://modelscope.oss-cn-beijing.aliyuncs.com/modelscope.gif" width="400"/>
+    <br>
+    <h1>FaceChain</h1>
+<p>
+
+
+
+# 介绍
+
+FaceChain是一个可以用来打造个人数字形象的深度学习模型工具。用户仅需要提供最低一张照片即可获得独属于自己的个人形象数字替身。FaceChain支持在gradio的界面中使用模型训练和推理能力，也支持资深开发者使用python脚本进行训练推理；同时，我们也欢迎开发者对本Repo进行继续开发和贡献。
+FaceChain的模型由[ModelScope](https://github.com/modelscope/modelscope)开源模型社区提供支持。
+
+<p align="center">
+        ModelScope Studio <a href="https://modelscope.cn/studios/CVstudio/cv_human_portrait/summary">🤖<a></a>&nbsp ｜ HuggingFace Space <a href="https://huggingface.co/spaces/modelscope/FaceChain">🤗</a>&nbsp 
+</p>
+<br>
+
+![image](resources/git_cover_CH.jpg)
+![image](resources/git_cover_1.jpg)
+![image](resources/git_cover_2.jpg)
+
+
+# News
+- 高性能的(单人&双人)模版重绘功能，简化用户界面. (2023-09-09)
+- 更多技术细节可以在 [论文](https://arxiv.org/abs/2308.14256) 里查看. (2023-08-30)
+- 为Lora训练添加验证和根据face_id的融合，并添加InpaintTab（目前在Gradio界面上暂时默认隐藏）. (2023-08-28)
+- 增加姿势控制模块，可一键体验模版pose复刻. (2023-08-27)
+- 增加鲁棒性人脸lora训练，提升单图训练&风格lora融合的效果. (2023-08-27)
+- 支持在HuggingFace Space中体验FaceChain ！ <a href="https://huggingface.co/spaces/modelscope/FaceChain">🤗</a>      (2023-08-25)
+- 新增高质量提示词模板，欢迎大家一起贡献！ 参考 [awesome-prompts-facechain](resources/awesome-prompts-facechain.txt)    (2023-08-18)
+- 支持即插即用的风格LoRA模型！ (2023-08-16)
+- 新增个性化prompt模块！ (2023-08-16)
+- Colab notebook安装已支持，您可以直接打开链接体验FaceChain： [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/modelscope/facechain/blob/main/facechain_demo.ipynb)   (2023-08-15)
+
+
+# 待办事项
+- 现成风格模型即插即用（以C站风格模型为例）   --迭代中
+- 增加更多美肤功能
+- 适配更多的基模，例如SDXL
+- 增加超分模块
+- 支持多人保id照片生成
+- 开发更多好玩的app
+
+
+# Citation
+
+如果FaceChain对您的研究有所帮助，请在您的出版物中引用FaceChain
+```
+@article{liu2023facechain,
+  title={FaceChain: A Playground for Identity-Preserving Portrait Generation},
+  author={Liu, Yang and Yu, Cheng and Shang, Lei and Wu, Ziheng and 
+          Wang, Xingjun and Zhao, Yuze and Zhu, Lin and Cheng, Chen and 
+          Chen, Weitao and Xu, Chao and Xie, Haoyu and Yao, Yuan and 
+          Zhou,  Wenmeng and Chen Yingda and Xie, Xuansong and Sun, Baigui},
+  journal={arXiv preprint arXiv:2308.14256},
+  year={2023}
+```
+
+# 环境准备
+
+## 兼容性验证
+FaceChain是一个组合模型，使用了包括PyTorch和TensorFlow在内的机器学习框架，以下是已经验证过的主要环境依赖：
+- python环境: py3.8, py3.10
+- pytorch版本: torch2.0.0, torch2.0.1
+- tensorflow版本: 2.8.0, tensorflow-cpu
+- CUDA版本: 11.7
+- CUDNN版本: 8+
+- 操作系统版本: Ubuntu 20.04, CentOS 7.9
+- GPU型号: Nvidia-A10 24G
+
+
+## 资源要求
+- GPU: 显存占用约19G
+- 磁盘: 推荐预留50GB以上的存储空间
+
+
+## 安装指南
+支持以下几种安装方式，任选其一：
+
+### 1. 使用ModelScope提供的notebook环境【推荐】
+ModelScope(魔搭社区)提供给新用户初始的免费计算资源，参考[ModelScope Notebook](https://modelscope.cn/my/mynotebook/preset)
+    
+如果初始免费计算资源无法满足要求，您还可以从上述页面开通付费流程，以便创建一个准备就绪的ModelScope(GPU) DSW镜像实例。
+    
+Notebook环境使用简单，您只需要按以下步骤操作（注意：目前暂不提供永久存储，实例重启后数据会丢失）：
+
+
+```shell
+# Step1: 我的notebook -> PAI-DSW -> GPU环境
+
+# Step2: 进入Notebook cell，执行下述命令从github clone代码：
+!GIT_LFS_SKIP_SMUDGE=1 git clone https://github.com/modelscope/facechain.git --depth 1
+
+# Step3: 切换当前工作路径
+import os
+os.chdir('/mnt/workspace/facechain')    # 注意替换成上述clone后的代码文件夹主路径
+print(os.getcwd())
+
+!pip3 install gradio
+!pip3 install controlnet_aux==0.0.6
+!pip3 install python-slugify
+!python3 app.py
+
+# Step4: 点击生成的URL即可访问web页面，上传照片开始训练和预测
+```
+
+除了ModelScope入口以外，您也可以前往[PAI-DSW](https://www.aliyun.com/activity/bigdata/pai/dsw) 直接购买带有ModelScope镜像的计算实例（推荐使用A10资源），这样同样可以使用如上的最简步骤运行起来。
+
+
+
+### 2. docker镜像
+
+如果您熟悉docker，可以使用我们提供的docker镜像，其包含了模型依赖的所有组件，无需复杂的环境安装：
+```shell
+# Step1: 机器资源
+您可以使用本地或云端带有GPU资源的运行环境。
+如需使用阿里云ECS，可访问： https://www.aliyun.com/product/ecs，推荐使用”镜像市场“中的CentOS 7.9 64位(预装NVIDIA GPU驱动)
+
+# Step2: 将镜像下载到本地 （前提是已经安装了docker engine并启动服务，具体可参考： https://docs.docker.com/engine/install/）
+docker pull registry.cn-hangzhou.aliyuncs.com/modelscope-repo/modelscope:ubuntu20.04-cuda11.7.1-py38-torch2.0.1-tf1.15.5-1.8.0
+
+# Step3: 拉起镜像运行
+docker run -it --name facechain -p 7860:7860 --gpus all registry.cn-hangzhou.aliyuncs.com/modelscope-repo/modelscope:ubuntu20.04-cuda11.7.1-py38-torch2.0.1-tf1.15.5-1.8.0 /bin/bash  # 注意 your_xxx_image_id 替换成你的镜像id
+# (注意： 如果提示无法使用宿主机GPU的错误，可能需要安装nvidia-container-runtime, 参考：https://github.com/NVIDIA/nvidia-container-runtime)
+
+# Step4: 在容器中安装gradio
+pip3 install gradio
+pip3 install controlnet_aux==0.0.6
+pip3 install python-slugify
+
+# Step5: 获取facechain源代码
+GIT_LFS_SKIP_SMUDGE=1 git clone https://github.com/modelscope/facechain.git --depth 1
+cd facechain
+python3 app.py
+# Note: FaceChain目前支持单卡GPU，如果您的环境有多卡，请使用如下命令
+# CUDA_VISIBLE_DEVICES=0 python3 app.py
+
+# Step6: 点击 "public URL", 形式为 https://xxx.gradio.live
+```
+
+
+### 3. conda虚拟环境
+
+使用conda虚拟环境，参考[Anaconda](https://docs.anaconda.com/anaconda/install/)来管理您的依赖，安装完成后，执行如下命令：
+(提示： mmcv对环境要求较高，可能出现不适配的情况，推荐使用docker方式)
+
+```shell
+conda create -n facechain python=3.8    # 已验证环境：3.8 和 3.10
+conda activate facechain
+
+GIT_LFS_SKIP_SMUDGE=1 git clone https://github.com/modelscope/facechain.git --depth 1
+cd facechain
+
+pip3 install -r requirements.txt
+pip3 install -U openmim 
+mim install mmcv-full==1.7.0
+
+# 进入facechain文件夹，执行：
+python3 app.py
+# Note: FaceChain目前支持单卡GPU，如果您的环境有多卡，请使用如下命令
+# CUDA_VISIBLE_DEVICES=0 python3 app.py
+
+# 最后点击log中生成的URL即可访问页面。
+```
+
+备注：如果是Windows环境还需要注意以下步骤：
+```shell
+# 1. 重新安装pytorch、与tensorflow匹配的numpy
+# 2. pip方式安装mmcv-full: pip3 install mmcv-full
+```
+
+### 4. colab运行
+
+| Colab | Info
+| --- | --- |
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/modelscope/facechain/blob/main/facechain_demo.ipynb) | FaceChain Installation on Colab
+
+
+
+备注：app服务成功启动后，在log中访问页面URL，进入”形象定制“tab页，点击“选择图片上传”，并最少选1张包含人脸的图片；点击“开始训练”即可训练模型。训练完成后日志中会有对应展示，之后切换到“形象体验”标签页点击“开始生成”即可生成属于自己的数字形象。
+
+# 脚本运行
+
+如果不想启动服务，而是直接在命令行进行开发调试等工作，FaceChain也支持在python环境中直接运行脚本进行训练和推理。在克隆后的文件夹中直接运行如下命令来进行训练：
+
+```shell
+PYTHONPATH=. sh train_lora.sh "ly261666/cv_portrait_model" "v2.0" "film/film" "./imgs" "./processed" "./output"
+```
+
+参数含义：
+
+```text
+ly261666/cv_portrait_model: ModelScope模型仓库的stable diffusion基模型，该模型会用于训练，可以不修改
+v2.0: 该基模型的版本号，可以不修改
+film/film: 该基模型包含了多个不同风格的子目录，其中使用了film/film目录中的风格模型，可以不修改
+./imgs: 本参数需要用实际值替换，本参数是一个本地文件目录，包含了用来训练和生成的原始照片
+./processed: 预处理之后的图片文件夹，这个参数需要在推理中被传入相同的值，可以不修改
+./output: 训练生成保存模型weights的文件夹，可以不修改
+```
+
+等待5-20分钟即可训练完成。用户也可以调节其他训练超参数，训练支持的超参数可以查看`train_lora.sh`的配置，或者`facechain/train_text_to_image_lora.py`中的完整超参数列表。
+
+进行推理时，请编辑run_inference.py中的代码:
+
+```python
+# 使用深度控制，默认False，仅在使用姿态控制时生效
+use_depth_control = False
+# 使用姿态控制，默认False
+use_pose_model = False
+# 姿态控制图片路径，仅在使用姿态控制时生效
+pose_image = 'poses/man/pose1.png'
+# 填入上述的预处理之后的图片文件夹，需要和训练时相同
+processed_dir = './processed'
+# 推理生成的图片数量
+num_generate = 5
+# 训练时使用的stable diffusion基模型，可以不修改
+base_model = 'ly261666/cv_portrait_model'
+# 该基模型的版本号，可以不修改
+revision = 'v2.0'
+# 该基模型包含了多个不同风格的子目录，其中使用了film/film目录中的风格模型，可以不修改
+base_model_sub_dir = 'film/film'
+# 训练生成保存模型weights的文件夹，需要保证和训练时相同
+train_output_dir = './output'
+# 指定一个保存生成的图片的文件夹，本参数可以根据需要修改
+output_dir = './generated'
+# 使用凤冠霞帔风格模型，默认False
+use_style = False
+```
+
+之后执行：
+
+```python
+python run_inference.py
+```
+
+即可在`output_dir`中找到生成的个人数字形象照片。
+                                             
+# 算法介绍
+
+## 基本原理
+
+个人写真模型的能力来源于Stable Diffusion模型的文生图功能，输入一段文本或一系列提示词，输出对应的图像。我们考虑影响个人写真生成效果的主要因素：写真风格信息，以及用户人物信息。为此，我们分别使用线下训练的风格LoRA模型和线上训练的人脸LoRA模型以学习上述信息。LoRA是一种具有较少可训练参数的微调模型，在Stable Diffusion中，可以通过对少量输入图像进行文生图训练的方式将输入图像的信息注入到LoRA模型中。因此，个人写真模型的能力分为训练与推断两个阶段，训练阶段生成用于微调Stable Diffusion模型的图像与文本标签数据，得到人脸LoRA模型；推断阶段基于人脸LoRA模型和风格LoRA模型生成个人写真图像。  
+    
+![image](resources/framework.jpg)
+
+## 训练阶段
+
+输入：用户上传的包含清晰人脸区域的图像
+                                             
+输出：人脸LoRA模型
+                                             
+描述：首先，我们分别使用基于朝向判断的图像旋转模型，以及基于人脸检测和关键点模型的人脸精细化旋转方法处理用户上传图像，得到包含正向人脸的图像；接下来，我们使用人体解析模型和人像美肤模型，以获得高质量的人脸训练图像；随后，我们使用人脸属性模型和文本标注模型，结合标签后处理方法，产生训练图像的精细化标签；最后，我们使用上述图像和标签数据微调Stable Diffusion模型得到人脸LoRA模型。
+
+## 推断阶段
+
+输入：训练阶段用户上传图像，预设的用于生成个人写真的输入提示词
+                                             
+输出：个人写真图像
+                                             
+描述：首先，我们将人脸LoRA模型和风格LoRA模型的权重融合到Stable Diffusion模型中；接下来，我们使用Stable Diffusion模型的文生图功能，基于预设的输入提示词初步生成个人写真图像；随后，我们使用人脸融合模型进一步改善上述写真图像的人脸细节，其中用于融合的模板人脸通过人脸质量评估模型在训练图像中挑选；最后，我们使用人脸识别模型计算生成的写真图像与模板人脸的相似度，以此对写真图像进行排序，并输出排名靠前的个人写真图像作为最终输出结果。    
+
+## 模型列表
+
+附（流程图中模型链接）
+
+[1]  人脸检测+关键点模型DamoFD：https://modelscope.cn/models/damo/cv_ddsar_face-detection_iclr23-damofd
+
+[2]  图像旋转模型：创空间内置模型
+
+[3]  人体解析模型M2FP：https://modelscope.cn/models/damo/cv_resnet101_image-multiple-human-parsing
+
+[4]  人像美肤模型ABPN：https://www.modelscope.cn/models/damo/cv_unet_skin_retouching_torch
+
+[5]  人脸属性模型FairFace：https://modelscope.cn/models/damo/cv_resnet34_face-attribute-recognition_fairface
+
+[6]  文本标注模型Deepbooru：https://github.com/KichangKim/DeepDanbooru
+
+[7]  模板脸筛选模型FQA：https://modelscope.cn/models/damo/cv_manual_face-quality-assessment_fqa
+
+[8]  人脸融合模型：https://www.modelscope.cn/models/damo/cv_unet_face_fusion_torch
+
+[9]  人脸识别模型RTS：https://modelscope.cn/models/damo/cv_ir_face-recognition-ood_rts                                  
+
+# 更多信息
+
+- [ModelScope library](https://github.com/modelscope/modelscope/)
+
+  ModelScope Library是一个托管于github上的模型生态仓库，隶属于达摩院魔搭项目。
+
+- [贡献模型到ModelScope](https://modelscope.cn/docs/ModelScope%E6%A8%A1%E5%9E%8B%E6%8E%A5%E5%85%A5%E6%B5%81%E7%A8%8B%E6%A6%82%E8%A7%88)
+
+# License
+
+This project is licensed under the [Apache License (Version 2.0)](https://github.com/modelscope/modelscope/blob/master/LICENSE).
+

facechain/app.py

@@ -0,0 +1,1007 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+import enum
+import os
+import shutil
+import slugify
+import time
+from concurrent.futures import ProcessPoolExecutor
+from torch import multiprocessing
+import cv2
+import gradio as gr
+import numpy as np
+import torch
+from glob import glob
+import platform
+import subprocess
+from facechain.utils import snapshot_download
+
+from facechain.inference import preprocess_pose, GenPortrait
+from facechain.inference_inpaint import GenPortrait_inpaint
+from facechain.train_text_to_image_lora import prepare_dataset, data_process_fn
+from facechain.constants import neg_prompt, pos_prompt_with_cloth, pos_prompt_with_style, styles, \
+    pose_models, pose_examples, base_models
+
+training_done_count = 0
+inference_done_count = 0
+
+class UploadTarget(enum.Enum):
+    PERSONAL_PROFILE = 'Personal Profile'
+    LORA_LIaBRARY = 'LoRA Library'
+
+# utils
+def concatenate_images(images):
+    heights = [img.shape[0] for img in images]
+    max_width = sum([img.shape[1] for img in images])
+
+    concatenated_image = np.zeros((max(heights), max_width, 3), dtype=np.uint8)
+    x_offset = 0
+    for img in images:
+        concatenated_image[0:img.shape[0], x_offset:x_offset + img.shape[1], :] = img
+        x_offset += img.shape[1]
+    return concatenated_image
+    
+def select_function(evt: gr.SelectData):
+    matched = list(filter(lambda item: evt.value == item['name'], styles))
+    style = matched[0]
+    return gr.Text.update(value=style['name'], visible=True)
+
+def update_prompt(style_model):
+    matched = list(filter(lambda item: style_model == item['name'], styles))
+    style = matched[0]
+    pos_prompt = generate_pos_prompt(style['name'], style['add_prompt_style'])
+    multiplier_style = style['multiplier_style']
+    multiplier_human = style['multiplier_human']
+    return gr.Textbox.update(value=pos_prompt), \
+           gr.Slider.update(value=multiplier_style), \
+           gr.Slider.update(value=multiplier_human)
+
+def update_pose_model(pose_image, pose_model):
+    if pose_image is None:
+        return gr.Radio.update(value=pose_models[0]['name']), gr.Image.update(visible=False)
+    else:
+        if pose_model == 0:
+            pose_model = 1
+        pose_res_img = preprocess_pose(pose_image)
+        return gr.Radio.update(value=pose_models[pose_model]['name']), gr.Image.update(value=pose_res_img, visible=True)
+
+def update_optional_styles(base_model_index):
+    style_list = base_models[base_model_index]['style_list']
+    optional_styles = '\n'.join(style_list)
+    return gr.Textbox.update(value=optional_styles)
+
+def train_lora_fn(base_model_path=None, revision=None, sub_path=None, output_img_dir=None, work_dir=None, photo_num=0):
+    torch.cuda.empty_cache()
+    
+    lora_r = 4
+    lora_alpha = 32 
+    max_train_steps = min(photo_num * 200, 800)
+
+    if platform.system() == 'Windows':
+        command = [
+            'accelerate', 'launch', 'facechain/train_text_to_image_lora.py',
+            f'--pretrained_model_name_or_path={base_model_path}',
+            f'--revision={revision}',
+            f'--sub_path={sub_path}',
+            f'--output_dataset_name={output_img_dir}',
+            '--caption_column=text',
+            '--resolution=512',
+            '--random_flip',
+            '--train_batch_size=1',
+            '--num_train_epochs=200',
+            '--checkpointing_steps=5000',
+            '--learning_rate=1.5e-04',
+            '--lr_scheduler=cosine',
+            '--lr_warmup_steps=0',
+            '--seed=42',
+            f'--output_dir={work_dir}',
+            f'--lora_r={lora_r}',
+            f'--lora_alpha={lora_alpha}',
+            '--lora_text_encoder_r=32',
+            '--lora_text_encoder_alpha=32',
+            '--resume_from_checkpoint="fromfacecommon"'
+        ]
+
+        try:
+            subprocess.run(command, check=True)
+        except subprocess.CalledProcessError as e:
+            print(f"Error executing the command: {e}")
+    else:
+        os.system(
+            f'PYTHONPATH=. accelerate launch facechain/train_text_to_image_lora.py '
+            f'--pretrained_model_name_or_path={base_model_path} '
+            f'--revision={revision} '
+            f'--sub_path={sub_path} '
+            f'--output_dataset_name={output_img_dir} '
+            f'--caption_column="text" '
+            f'--resolution=512 '
+            f'--random_flip '
+            f'--train_batch_size=1 '
+            f'--num_train_epochs=200 '
+            f'--checkpointing_steps=5000 '
+            f'--learning_rate=1.5e-04 '
+            f'--lr_scheduler="cosine" '
+            f'--lr_warmup_steps=0 '
+            f'--seed=42 '
+            f'--output_dir={work_dir} '
+            f'--lora_r={lora_r} '
+            f'--lora_alpha={lora_alpha} '
+            f'--lora_text_encoder_r=32 '
+            f'--lora_text_encoder_alpha=32 '
+            f'--resume_from_checkpoint="fromfacecommon"')
+
+def generate_pos_prompt(style_model, prompt_cloth):
+    if style_model in base_models[0]['style_list'][:-1] or style_model is None:
+        pos_prompt = pos_prompt_with_cloth.format(prompt_cloth)
+    else:
+        matched = list(filter(lambda style: style_model == style['name'], styles))
+        if len(matched) == 0:
+            raise ValueError(f'styles not found: {style_model}')
+        matched = matched[0]
+        pos_prompt = pos_prompt_with_style.format(matched['add_prompt_style'])
+    return pos_prompt
+
+def launch_pipeline(uuid,
+                    pos_prompt,
+                    neg_prompt=None,
+                    base_model_index=None,
+                    user_model=None,
+                    num_images=1,
+                    lora_choice=None,
+                    style_model=None,
+                    multiplier_style=0.25,
+                    multiplier_human=0.85,
+                    pose_model=None,
+                    pose_image=None
+                    ):
+    if not uuid:
+        if os.getenv("MODELSCOPE_ENVIRONMENT") == 'studio':
+            return "请登陆后使用! (Please login first)"
+        else:
+            uuid = 'qw'
+    
+    # Check base model
+    if base_model_index == None:
+        raise gr.Error('请选择基模型(Please select the base model)!')
+    
+    # Check character LoRA
+    base_model_path = base_models[base_model_index]['model_id']
+    folder_path = f"/tmp/{uuid}/{base_model_path}"
+    folder_list = []
+    if os.path.exists(folder_path):
+        files = os.listdir(folder_path)
+        for file in files:
+            file_path = os.path.join(folder_path, file)
+            if os.path.isdir(folder_path):
+                file_lora_path = f"{file_path}/pytorch_lora_weights.bin"
+                if os.path.exists(file_lora_path):
+                    folder_list.append(file)
+    if len(folder_list) == 0:
+        raise gr.Error('该基模型下没有人物LoRA，请先训练(There is no character LoRA under this base model, please train first)!')
+
+    # Check output model
+    if user_model == None:
+        raise gr.Error('请选择人物LoRA(Please select the character LoRA)！')
+    # Check lora choice
+    if lora_choice == None:
+        raise gr.Error('请选择LoRA模型(Please select the LoRA model)!')
+    # Check style model
+    if style_model == None and lora_choice == 'preset':
+        raise gr.Error('请选择风格模型(Please select the style model)!')
+
+    base_model = base_models[base_model_index]['model_id']
+    revision = base_models[base_model_index]['revision']
+    sub_path = base_models[base_model_index]['sub_path']
+    
+    before_queue_size = 0
+    before_done_count = inference_done_count
+    matched = list(filter(lambda item: style_model == item['name'], styles))
+    style_model = matched[0]['name']
+
+    if lora_choice == 'preset':
+        if style_model in base_models[0]['style_list'][:-1]:
+            style_model_path = None
+        else:
+            matched = list(filter(lambda style: style_model == style['name'], styles))
+            if len(matched) == 0:
+                raise ValueError(f'styles not found: {style_model}')
+            matched = matched[0]
+            model_dir = snapshot_download(matched['model_id'], revision=matched['revision'])
+            style_model_path = os.path.join(model_dir, matched['bin_file'])
+    else:
+        print(f'uuid: {uuid}')
+        temp_lora_dir = f"/tmp/{uuid}/temp_lora"
+        file_name = lora_choice
+        print(lora_choice.split('.')[-1], os.path.join(temp_lora_dir, file_name))
+        if lora_choice.split('.')[-1] != 'safetensors' or not os.path.exists(os.path.join(temp_lora_dir, file_name)):
+            raise ValueError(f'Invalid lora file: {lora_file.name}')
+        style_model_path = os.path.join(temp_lora_dir, file_name)
+
+    if pose_image is None or pose_model == 0:
+        pose_model_path = None
+        use_depth_control = False
+        pose_image = None
+    else:
+        model_dir = snapshot_download('damo/face_chain_control_model', revision='v1.0.1')
+        pose_model_path = os.path.join(model_dir, 'model_controlnet/control_v11p_sd15_openpose')
+        if pose_model == 1:
+            use_depth_control = True
+        else:
+            use_depth_control = False
+
+    print("-------user_model: ", user_model)
+    if not uuid:
+        if os.getenv("MODELSCOPE_ENVIRONMENT") == 'studio':
+            return "请登陆后使用! (Please login first)"
+        else:
+            uuid = 'qw'
+
+    use_main_model = True
+    use_face_swap = True
+    use_post_process = True
+    use_stylization = False
+
+    instance_data_dir = os.path.join('/tmp', uuid, 'training_data', base_model, user_model)
+    lora_model_path = f'/tmp/{uuid}/{base_model}/{user_model}/ensemble'
+    if not os.path.exists(lora_model_path):
+        lora_model_path = f'/tmp/{uuid}/{base_model}/{user_model}/'
+
+    gen_portrait = GenPortrait(pose_model_path, pose_image, use_depth_control, pos_prompt, neg_prompt, style_model_path, 
+                               multiplier_style, multiplier_human, use_main_model,
+                               use_face_swap, use_post_process,
+                               use_stylization)
+
+    num_images = min(6, num_images)
+
+    with ProcessPoolExecutor(max_workers=5) as executor:
+        future = executor.submit(gen_portrait, instance_data_dir,
+                                            num_images, base_model, lora_model_path, sub_path, revision)
+        while not future.done():
+            is_processing = future.running()
+            if not is_processing:
+                cur_done_count = inference_done_count
+                to_wait = before_queue_size - (cur_done_count - before_done_count)
+                yield ["排队等待资源中, 前方还有{}个生成任务, 预计需要等待{}分钟...".format(to_wait, to_wait * 2.5),
+                        None]
+            else:
+                yield ["生成中, 请耐心等待(Generating)...", None]
+            time.sleep(1)
+
+    outputs = future.result()
+    outputs_RGB = []
+    for out_tmp in outputs:
+        outputs_RGB.append(cv2.cvtColor(out_tmp, cv2.COLOR_BGR2RGB))
+        
+    save_dir = os.path.join('/tmp', uuid, 'inference_result', base_model, user_model)
+    if lora_choice == 'preset':
+        save_dir = os.path.join(save_dir, 'style_' + style_model)
+    else:
+        save_dir = os.path.join(save_dir, 'lora_' + os.path.basename(lora_choice).split('.')[0])
+    
+    if not os.path.exists(save_dir):
+        os.makedirs(save_dir)
+    # use single to save outputs
+    if not os.path.exists(os.path.join(save_dir, 'single')):
+        os.makedirs(os.path.join(save_dir, 'single'))
+    for img in outputs:
+        # count the number of images in the folder
+        num = len(os.listdir(os.path.join(save_dir, 'single')))
+        cv2.imwrite(os.path.join(save_dir, 'single', str(num) + '.png'), img)
+    
+    if len(outputs) > 0:
+        result = concatenate_images(outputs)
+        if not os.path.exists(os.path.join(save_dir, 'concat')):
+            os.makedirs(os.path.join(save_dir, 'concat'))
+        num = len(os.listdir(os.path.join(save_dir, 'concat')))
+        image_path = os.path.join(save_dir, 'concat', str(num) + '.png')
+        cv2.imwrite(image_path, result)
+
+        yield ["生成完毕(Generation done)!", outputs_RGB]
+    else:
+        yield ["生成失败, 请重试(Generation failed, please retry)!", outputs_RGB]
+
+def launch_pipeline_inpaint(uuid,
+                            base_model_index=None,
+                            user_model_A=None,
+                            user_model_B=None,
+                            num_faces=1,
+                            template_image=None):
+    before_queue_size = 0
+    before_done_count = inference_done_count
+
+    if not uuid:
+        if os.getenv("MODELSCOPE_ENVIRONMENT") == 'studio':
+            return "请登陆后使用! (Please login first)"
+        else:
+            uuid = 'qw'
+
+    # Check base model
+    if base_model_index == None:
+        raise gr.Error('请选择基模型(Please select the base model)！')
+
+    # Check character LoRA
+    base_model_path = base_models[base_model_index]['model_id']
+    folder_path = f"/tmp/{uuid}/{base_model_path}"
+    folder_list = []
+    if os.path.exists(folder_path):
+        files = os.listdir(folder_path)
+        for file in files:
+            file_path = os.path.join(folder_path, file)
+            if os.path.isdir(folder_path):
+                file_lora_path = f"{file_path}/pytorch_lora_weights.bin"
+                if os.path.exists(file_lora_path):
+                    folder_list.append(file)
+    if len(folder_list) == 0:
+        raise gr.Error('该基模型下没有人物LoRA，请先训练(There is no character LoRA under this base model, please train first)!')
+
+
+    # Check character LoRA
+    if num_faces == 1:
+        if user_model_A == None:
+            raise gr.Error('请至少选择一个人物LoRA(Please select at least one character LoRA)！')
+    else:
+        if user_model_A == None and user_model_B == None:
+            raise gr.Error('请至少选择一个人物LoRA(Please select at least one character LoRA)！')
+
+    if not uuid:
+        if os.getenv("MODELSCOPE_ENVIRONMENT") == 'studio':
+            return "请登陆后使用! (Please login first)"
+        else:
+            uuid = 'qw'
+
+    if isinstance(template_image, str):
+        if len(template_image) == 0:
+            raise gr.Error('请选择一张模板(Please select 1 template)')
+
+    base_model = base_models[base_model_index]['model_id']
+    revision = base_models[base_model_index]['revision']
+    sub_path = base_models[base_model_index]['sub_path']
+    multiplier_style = 0.05
+    multiplier_human = 0.95
+    strength = 0.65
+    output_img_size = 512
+
+    model_dir = snapshot_download('ly261666/cv_wanx_style_model', revision='v1.0.3')
+    style_model_path = os.path.join(model_dir, 'zjz_mj_jiyi_small_addtxt_frommajicreal.safetensors')
+
+    pos_prompt = 'raw photo, masterpiece, chinese, simple background, high-class pure color background, solo, medium shot, high detail face, photorealistic, best quality, wearing T-shirt'
+    neg_prompt = 'nsfw, paintings, sketches, (worst quality:2), (low quality:2) ' \
+                'lowers, normal quality, ((monochrome)), ((grayscale)), logo, word, character'
+
+    if user_model_A == '不重绘该人物(Do not inpaint this character)':
+        user_model_A = None
+    if user_model_B == '不重绘该人物(Do not inpaint this character)':
+        user_model_B = None
+           
+    if user_model_A is not None:
+        instance_data_dir_A = os.path.join('/tmp', uuid, 'training_data', base_model, user_model_A)
+        lora_model_path_A = f'/tmp/{uuid}/{base_model}/{user_model_A}/'
+    else:
+        instance_data_dir_A = None
+        lora_model_path_A = None
+    if user_model_B is not None:
+        instance_data_dir_B = os.path.join('/tmp', uuid, 'training_data', base_model, user_model_B)
+        lora_model_path_B = f'/tmp/{uuid}/{base_model}/{user_model_B}/'
+    else:
+        instance_data_dir_B = None
+        lora_model_path_B = None
+
+    in_path = template_image
+    out_path = 'inpaint_rst'
+
+    use_main_model = True
+    use_face_swap = True
+    use_post_process = True
+    use_stylization = False
+
+    gen_portrait = GenPortrait_inpaint(in_path, strength, num_faces,
+                                    pos_prompt, neg_prompt, style_model_path,
+                                    multiplier_style, multiplier_human, use_main_model,
+                                    use_face_swap, use_post_process,
+                                    use_stylization)
+
+    with ProcessPoolExecutor(max_workers=5) as executor:
+        future = executor.submit(gen_portrait, instance_data_dir_A, instance_data_dir_B, base_model,\
+                                 lora_model_path_A, lora_model_path_B, sub_path=sub_path, revision=revision)
+
+        while not future.done():
+            is_processing = future.running()
+            if not is_processing:
+                cur_done_count = inference_done_count
+                to_wait = before_queue_size - (cur_done_count - before_done_count)
+                yield ["排队等待资源中，前方还有{}个生成任务, 预计需要等待{}分钟...".format(to_wait, to_wait * 2.5),
+                       None]
+            else:
+                yield ["生成中, 请耐心等待(Generating)...", None]
+            time.sleep(1)
+
+    outputs = future.result()
+    outputs_RGB = []
+    for out_tmp in outputs:
+        outputs_RGB.append(cv2.cvtColor(out_tmp, cv2.COLOR_BGR2RGB))
+
+
+    for i, out_tmp in enumerate(outputs):
+        cv2.imwrite('{}_{}.png'.format(out_path, i), out_tmp)
+
+    if len(outputs) > 0:   
+        yield ["生成完毕(Generation done)！", outputs_RGB]
+    else:
+        yield ["生成失败，请重试(Generation failed, please retry)！", outputs_RGB]
+
+
+class Trainer:
+    def __init__(self):
+        pass
+
+    def run(
+            self,
+            uuid: str,
+            instance_images: list,
+            base_model_index: int,
+            output_model_name: str,
+    ) -> str:
+        # Check Cuda
+        if not torch.cuda.is_available():
+            raise gr.Error('CUDA不可用(CUDA not available)')
+
+        # Check Instance Valid
+        if instance_images is None:
+            raise gr.Error('您需要上传训练图片(Please upload photos)!')
+        
+        # Check output model name
+        if not output_model_name:
+            raise gr.Error('请指定人物lora的名称(Please specify the character LoRA name)！')
+        
+        # Limit input Image
+        if len(instance_images) > 20:
+            raise gr.Error('请最多上传20张训练图片(20 images at most!)')
+
+        # Check UUID & Studio
+        if not uuid:
+            if os.getenv("MODELSCOPE_ENVIRONMENT") == 'studio':
+                return "请登陆后使用(Please login first)! "
+            else:
+                uuid = 'qw'
+
+        base_model_path = base_models[base_model_index]['model_id']
+        revision = base_models[base_model_index]['revision']
+        sub_path = base_models[base_model_index]['sub_path']
+        output_model_name = slugify.slugify(output_model_name)
+
+        # mv user upload data to target dir
+        instance_data_dir = os.path.join('/tmp', uuid, 'training_data', base_model_path, output_model_name)
+        print("--------uuid: ", uuid)
+
+        if not os.path.exists(f"/tmp/{uuid}"):
+            os.makedirs(f"/tmp/{uuid}")
+        work_dir = f"/tmp/{uuid}/{base_model_path}/{output_model_name}"
+
+        if os.path.exists(work_dir):
+            raise gr.Error("人物lora名称已存在。(This character lora name already exists.)")
+
+        print("----------work_dir: ", work_dir)
+        shutil.rmtree(work_dir, ignore_errors=True)
+        shutil.rmtree(instance_data_dir, ignore_errors=True)
+
+        prepare_dataset([img['name'] for img in instance_images], output_dataset_dir=instance_data_dir)
+        data_process_fn(instance_data_dir, True)
+
+        # train lora
+        print("instance_data_dir", instance_data_dir)
+        train_lora_fn(base_model_path=base_model_path,
+                      revision=revision,
+                      sub_path=sub_path,
+                      output_img_dir=instance_data_dir,
+                      work_dir=work_dir,
+                      photo_num=len(instance_images))
+
+        message = '''<center><font size=4>训练已经完成！请切换至 [无限风格形象写真] 标签体验模型效果。</center>
+        
+        <center><font size=4>(Training done, please switch to the Infinite Style Portrait tab to generate photos.)</center>'''
+        print(message)
+        return message
+
+
+def flash_model_list(uuid, base_model_index, lora_choice:gr.Dropdown):    
+
+    base_model_path = base_models[base_model_index]['model_id']
+    style_list = base_models[base_model_index]['style_list']
+
+    sub_styles=[]
+    for style in style_list:
+        matched = list(filter(lambda item: style == item['name'], styles))
+        sub_styles.append(matched[0])
+
+    if not uuid:
+        if os.getenv("MODELSCOPE_ENVIRONMENT") == 'studio':
+            return "请登陆后使用! (Please login first)"
+        else:
+            uuid = 'qw'
+
+    folder_path = f"/tmp/{uuid}/{base_model_path}"
+    folder_list = []
+    lora_save_path = f"/tmp/{uuid}/temp_lora"
+    if not os.path.exists(lora_save_path):
+        lora_list = ['preset']
+    else:
+        lora_list = sorted(os.listdir(lora_save_path))
+        lora_list = ["preset"] + lora_list
+    
+    if not os.path.exists(folder_path):
+        if lora_choice == 'preset':  
+            return gr.Radio.update(choices=[]), \
+                gr.Gallery.update(value=[(item["img"], item["name"]) for item in sub_styles], visible=True), \
+                gr.Text.update(value=style_list[0], visible=True), \
+                gr.Dropdown.update(choices=lora_list, visible=True), gr.File.update(visible=True)
+        else:
+            return gr.Radio.update(choices=[]), \
+                gr.Gallery.update(visible=False), gr.Text.update(),\
+                gr.Dropdown.update(choices=lora_list, visible=True), gr.File.update(visible=True)
+    else:
+        files = os.listdir(folder_path)
+        for file in files:
+            file_path = os.path.join(folder_path, file)
+            if os.path.isdir(folder_path):
+                file_lora_path = f"{file_path}/pytorch_lora_weights.bin"
+                if os.path.exists(file_lora_path):
+                    folder_list.append(file)
+    
+    if lora_choice == 'preset':
+        return gr.Radio.update(choices=folder_list), \
+            gr.Gallery.update(value=[(item["img"], item["name"]) for item in sub_styles], visible=True), \
+            gr.Text.update(value=style_list[0], visible=True), \
+            gr.Dropdown.update(choices=lora_list, visible=True), gr.File.update(visible=True)
+    else:
+        return gr.Radio.update(choices=folder_list), \
+            gr.Gallery.update(visible=False), gr.Text.update(), \
+            gr.Dropdown.update(choices=lora_list, visible=True), gr.File.update(visible=True)
+
+def update_output_model(uuid, base_model_index):
+
+    # Check base model
+    if base_model_index == None:
+        raise gr.Error('请选择基模型(Please select the base model)!')
+
+    base_model_path = base_models[base_model_index]['model_id']
+    style_list = base_models[base_model_index]['style_list']
+
+    if not uuid:
+        if os.getenv("MODELSCOPE_ENVIRONMENT") == 'studio':
+            return "请登陆后使用! (Please login first)"
+        else:
+            uuid = 'qw'
+
+    folder_path = f"/tmp/{uuid}/{base_model_path}"
+    folder_list = []
+    if not os.path.exists(folder_path):
+        return gr.Radio.update(choices=[]),gr.Dropdown.update(choices=style_list)
+    else:
+        files = os.listdir(folder_path)
+        for file in files:
+            file_path = os.path.join(folder_path, file)
+            if os.path.isdir(folder_path):
+                file_lora_path = f"{file_path}/pytorch_lora_weights.bin"
+                if os.path.exists(file_lora_path):
+                    folder_list.append(file)
+
+    return gr.Radio.update(choices=folder_list)
+
+def update_output_model_inpaint(uuid, base_model_index):
+    # Check base model
+    if base_model_index == None:
+        raise gr.Error('请选择基模型(Please select the base model)！')
+
+    base_model_path = base_models[base_model_index]['model_id']
+    style_list = base_models[base_model_index]['style_list']
+
+    if not uuid:
+        if os.getenv("MODELSCOPE_ENVIRONMENT") == 'studio':
+            return "请登陆后使用! (Please login first)"
+        else:
+            uuid = 'qw'
+
+    folder_path = f"/tmp/{uuid}/{base_model_path}"
+    folder_list = ['不重绘该人物(Do not inpaint this character)']
+    if not os.path.exists(folder_path):
+        return gr.Radio.update(choices=[]), gr.Dropdown.update(choices=style_list)
+    else:
+        files = os.listdir(folder_path)
+        for file in files:
+            file_path = os.path.join(folder_path, file)
+            if os.path.isdir(folder_path):
+                file_lora_path = f"{file_path}/pytorch_lora_weights.bin"
+                if os.path.exists(file_lora_path):
+                    folder_list.append(file)
+
+    return gr.Radio.update(choices=folder_list, value=folder_list[0]), gr.Radio.update(choices=folder_list, value=folder_list[0])
+
+def update_output_model_num(num_faces):
+    if num_faces == 1:
+        return gr.Radio.update(), gr.Radio.update(visible=False)
+    else:
+        return gr.Radio.update(), gr.Radio.update(visible=True)
+
+def upload_file(files, current_files):
+    file_paths = [file_d['name'] for file_d in current_files] + [file.name for file in files]
+    return file_paths
+
+def upload_lora_file(uuid, lora_file):
+    if not uuid:
+        if os.getenv("MODELSCOPE_ENVIRONMENT") == 'studio':
+            return "请登陆后使用! (Please login first)"
+        else:
+            uuid = 'qw'
+    print("uuid: ", uuid)
+    temp_lora_dir = f"/tmp/{uuid}/temp_lora"
+    if not os.path.exists(temp_lora_dir):
+        os.makedirs(temp_lora_dir)
+    shutil.copy(lora_file.name, temp_lora_dir)
+    filename = os.path.basename(lora_file.name)
+    newfilepath = os.path.join(temp_lora_dir, filename)
+    print("newfilepath: ", newfilepath)
+    
+    lora_list = sorted(os.listdir(temp_lora_dir))
+    lora_list = ["preset"] + lora_list
+    
+    return gr.Dropdown.update(choices=lora_list, value=filename)
+
+def clear_lora_file(uuid, lora_file):
+    if not uuid:
+        if os.getenv("MODELSCOPE_ENVIRONMENT") == 'studio':
+            return "请登陆后使用! (Please login first)"
+        else:
+            uuid = 'qw'
+    
+    return gr.Dropdown.update(value="preset")
+
+def change_lora_choice(lora_choice, base_model_index):
+    style_list = base_models[base_model_index]['style_list']
+    sub_styles=[]
+    for style in style_list:
+        matched = list(filter(lambda item: style == item['name'], styles))
+        sub_styles.append(matched[0])
+    
+    if lora_choice == 'preset':
+        return gr.Gallery.update(value=[(item["img"], item["name"]) for item in sub_styles], visible=True), \
+               gr.Text.update(value=style_list[0])
+    else:
+        return gr.Gallery.update(visible=False), gr.Text.update(visible=False)
+
+def deal_history(uuid, base_model_index=None , user_model=None, lora_choice=None, style_model=None, deal_type="load"):
+    if not uuid:
+        if os.getenv("MODELSCOPE_ENVIRONMENT") == 'studio':
+            return "请登陆后使用! (Please login first)"
+        else:
+            uuid = 'qw'
+    
+    if base_model_index is None:
+        raise gr.Error('请选择基模型(Please select the base model)!')
+    if user_model is None:
+        raise gr.Error('请选择人物lora(Please select the character lora)!')    
+    if lora_choice is None:
+        raise gr.Error('请选择LoRa文件(Please select the LoRa file)!')
+    if style_model is None and lora_choice == 'preset':
+        raise gr.Error('请选择风格(Please select the style)!')
+    
+    base_model = base_models[base_model_index]['model_id']
+    matched = list(filter(lambda item: style_model == item['name'], styles))
+    style_model = matched[0]['name']
+
+    save_dir = os.path.join('/tmp', uuid, 'inference_result', base_model, user_model)
+    if lora_choice == 'preset':
+        save_dir = os.path.join(save_dir, 'style_' + style_model)
+    else:
+        save_dir = os.path.join(save_dir, 'lora_' + os.path.basename(lora_choice).split('.')[0])
+    
+    if not os.path.exists(save_dir):
+        return gr.Gallery.update(value=[], visible=True), gr.Gallery.update(value=[], visible=True)
+    
+    if deal_type == "load":
+        single_dir = os.path.join(save_dir, 'single')
+        concat_dir = os.path.join(save_dir, 'concat')
+        single_imgs = []
+        concat_imgs = []
+        if os.path.exists(single_dir):
+            single_imgs = sorted(os.listdir(single_dir))
+            single_imgs = [os.path.join(single_dir, img) for img in single_imgs]
+        if os.path.exists(concat_dir):
+            concat_imgs = sorted(os.listdir(concat_dir))
+            concat_imgs = [os.path.join(concat_dir, img) for img in concat_imgs]
+        
+        return gr.Gallery.update(value=single_imgs, visible=True), gr.Gallery.update(value=concat_imgs, visible=True)
+    elif deal_type == "delete":
+        shutil.rmtree(save_dir)
+        return gr.Gallery.update(value=[], visible=True), gr.Gallery.update(value=[], visible=True)
+    
+def train_input():
+    trainer = Trainer()
+
+    with gr.Blocks() as demo:
+        uuid = gr.Text(label="modelscope_uuid", visible=False)
+        with gr.Row():
+            with gr.Column():
+                with gr.Box():
+                    gr.Markdown('模型选择(Model list)')
+
+                    base_model_list = []
+                    for base_model in base_models:
+                        base_model_list.append(base_model['name'])
+
+                    base_model_index = gr.Radio(label="基模型选择(Base model list)", choices=base_model_list, type="index",
+                                       value=base_model_list[0])
+                    
+                    optional_style = '\n'.join(base_models[0]['style_list'])
+                    
+                    optional_styles = gr.Textbox(label="该基模型支持的风格(Styles supported by this base model.)", max_lines=5,
+                                        value=optional_style, interactive=False)
+                    
+                    output_model_name = gr.Textbox(label="人物lora名称(Character lora name)", value='person1', lines=1)
+
+                    gr.Markdown('训练图片(Training photos)')
+                    instance_images = gr.Gallery()
+                    with gr.Row():
+                        upload_button = gr.UploadButton("选择图片上传(Upload photos)", file_types=["image"],
+                                                        file_count="multiple")
+
+                        clear_button = gr.Button("清空图片(Clear photos)")
+                    clear_button.click(fn=lambda: [], inputs=None, outputs=instance_images)
+
+                    upload_button.upload(upload_file, inputs=[upload_button, instance_images], outputs=instance_images,
+                                         queue=False)
+                    
+                    gr.Markdown('''
+                        使用说明（Instructions）：
+                        ''')
+                    gr.Markdown('''
+                        - Step 1. 上传计划训练的图片, 1~10张头肩照(注意: 请避免图片中出现多人脸、脸部遮挡等情况, 否则可能导致效果异常)
+                        - Step 2. 点击 [开始训练] , 启动形象定制化训练, 每张图片约需1.5分钟, 请耐心等待～
+                        - Step 3. 切换至 [形象写真] , 生成你的风格照片<br/><br/>
+                        ''')
+                    gr.Markdown('''
+                        - Step 1. Upload 1-10 headshot photos of yours (Note: avoid photos with multiple faces or face obstruction, which may lead to non-ideal result).
+                        - Step 2. Click [Train] to start training for customizing your Digital-Twin, this may take up-to 1.5 mins per image.
+                        - Step 3. Switch to [Portrait] Tab to generate stylized photos.
+                        ''')
+
+        run_button = gr.Button('开始训练(等待上传图片加载显示出来再点, 否则会报错)... '
+                               'Start training (please wait until photo(s) fully uploaded, otherwise it may result in training failure)')
+
+        with gr.Box():
+            gr.Markdown('''
+            <center>请等待训练完成，请勿刷新或关闭页面。</center>
+
+            <center>(Please wait for the training to complete, do not refresh or close the page.)</center>
+            ''')
+            output_message = gr.Markdown()
+        with gr.Box():
+            gr.Markdown('''
+            碰到抓狂的错误或者计算资源紧张的情况下，推荐直接在[NoteBook](https://modelscope.cn/my/mynotebook/preset)上进行体验。
+
+            (If you are experiencing prolonged waiting time, you may try on [ModelScope NoteBook](https://modelscope.cn/my/mynotebook/preset) to prepare your dedicated environment.)
+
+            安装方法请参考：https://github.com/modelscope/facechain .
+
+            (You may refer to: https://github.com/modelscope/facechain for installation instruction.)
+            ''')
+        base_model_index.change(fn=update_optional_styles,
+                                inputs=[base_model_index],
+                                outputs=[optional_styles],
+                                queue=False)
+
+        run_button.click(fn=trainer.run,
+                         inputs=[
+                             uuid,
+                             instance_images,
+                             base_model_index,
+                             output_model_name,
+                         ],
+                         outputs=[output_message])
+
+    return demo
+
+def inference_input():
+    with gr.Blocks() as demo:
+        uuid = gr.Text(label="modelscope_uuid", visible=False)
+        
+        with gr.Row():
+            with gr.Column():
+                base_model_list = []
+                for base_model in base_models:
+                    base_model_list.append(base_model['name'])
+
+                base_model_index = gr.Radio(label="基模型选择(Base model list)", choices=base_model_list, type="index")
+                
+                with gr.Row():
+                    with gr.Column(scale=2):
+                        user_model = gr.Radio(label="人物LoRA列表(Character LoRAs)", choices=[], type="value")
+                    with gr.Column(scale=1):
+                        update_button = gr.Button('刷新人物LoRA列表(Refresh character LoRAs)')
+
+                with gr.Box():
+                    style_model = gr.Text(label='请选择一种风格(Select a style from the pics below):', interactive=False)
+                    gallery = gr.Gallery(value=[(item["img"], item["name"]) for item in styles],
+                                        label="风格(Style)",
+                                        allow_preview=False,
+                                        columns=5,
+                                        elem_id="gallery",
+                                        show_share_button=False,
+                                        visible=False)
+
+                pmodels = []
+                for pmodel in pose_models:
+                    pmodels.append(pmodel['name'])
+
+                with gr.Accordion("高级选项(Advanced Options)", open=False):
+                    # upload one lora file and show the name or path of the file
+                    with gr.Accordion("上传LoRA文件(Upload LoRA file)", open=False):
+                        lora_choice = gr.Dropdown(choices=["preset"], type="value", value="preset", label="LoRA文件(LoRA file)", visible=False)
+                        lora_file = gr.File(
+                            value=None,
+                            label="上传LoRA文件(Upload LoRA file)",
+                            type="file",
+                            file_types=[".safetensors"],
+                            file_count="single",
+                            visible=False,
+                        )
+                    
+                    pos_prompt = gr.Textbox(label="提示语(Prompt)", lines=3, 
+                                            value=generate_pos_prompt(None, styles[0]['add_prompt_style']),
+                                            interactive=True)
+                    neg_prompt = gr.Textbox(label="负向提示语(Negative Prompt)", lines=3,
+                                            value="",
+                                            interactive=True)
+                    multiplier_style = gr.Slider(minimum=0, maximum=1, value=0.25,
+                                                 step=0.05, label='风格权重(Multiplier style)')
+                    multiplier_human = gr.Slider(minimum=0, maximum=1.2, value=0.95,
+                                                 step=0.05, label='形象权重(Multiplier human)')
+                    
+                    with gr.Accordion("姿态控制(Pose control)", open=False):
+                        with gr.Row():
+                            pose_image = gr.Image(source='upload', type='filepath', label='姿态图片(Pose image)', height=250)
+                            pose_res_image = gr.Image(source='upload', interactive=False, label='姿态结果(Pose result)', visible=False, height=250)
+                        gr.Examples(pose_examples['man'], inputs=[pose_image], label='男性姿态示例')
+                        gr.Examples(pose_examples['woman'], inputs=[pose_image], label='女性姿态示例')
+                        pose_model = gr.Radio(choices=pmodels, value=pose_models[0]['name'],
+                                            type="index", label="姿态控制模型(Pose control model)")
+                with gr.Box():
+                    num_images = gr.Number(
+                        label='生成图片数量(Number of photos)', value=6, precision=1, minimum=1, maximum=6)
+                    gr.Markdown('''
+                    注意: 
+                    - 最多支持生成6张图片!(You may generate a maximum of 6 photos at one time!)
+                    - 可上传在定义LoRA文件使用, 否则默认使用风格模型的LoRA。(You may upload custome LoRA file, otherwise the LoRA file of the style model will be used by deault.)
+                    - 使用自定义LoRA文件需手动输入prompt, 否则可能无法正常触发LoRA文件风格。(You shall provide prompt when using custom LoRA, otherwise desired LoRA style may not be triggered.)
+                        ''')
+
+        with gr.Row():
+            display_button = gr.Button('开始生成(Start!)')   
+            with gr.Column():
+                history_button = gr.Button('查看历史(Show history)')
+                load_history_text = gr.Text("load", visible=False)
+                delete_history_button = gr.Button('删除历史(Delete history)')
+                delete_history_text = gr.Text("delete", visible=False)
+
+        with gr.Box():
+            infer_progress = gr.Textbox(label="生成进度(Progress)", value="当前无生成任务(No task)", interactive=False)
+        with gr.Box():
+            gr.Markdown('生成结果(Result)')
+            output_images = gr.Gallery(label='Output', show_label=False).style(columns=3, rows=2, height=600,
+                                                                               object_fit="contain")
+            
+        with gr.Accordion(label="历史生成结果(History)", open=False):
+            with gr.Row():
+                single_history = gr.Gallery(label='单张图片(Single image history)')
+                batch_history = gr.Gallery(label='图片组(Batch image history)')
+        
+        gallery.select(select_function, None, style_model, queue=False)
+        lora_choice.change(fn=change_lora_choice, inputs=[lora_choice, base_model_index], outputs=[gallery, style_model], queue=False)
+        
+        lora_file.upload(fn=upload_lora_file, inputs=[uuid, lora_file], outputs=[lora_choice], queue=False)
+        lora_file.clear(fn=clear_lora_file, inputs=[uuid, lora_file], outputs=[lora_choice], queue=False)
+        
+        style_model.change(update_prompt, style_model, [pos_prompt, multiplier_style, multiplier_human], queue=False)
+        pose_image.change(update_pose_model, [pose_image, pose_model], [pose_model, pose_res_image])
+        base_model_index.change(fn=flash_model_list,
+                                inputs=[uuid, base_model_index, lora_choice],
+                                outputs=[user_model, gallery, style_model, lora_choice, lora_file],
+                                queue=False)
+        update_button.click(fn=update_output_model,
+                      inputs=[uuid, base_model_index],
+                      outputs=[user_model],
+                      queue=False)
+        display_button.click(fn=launch_pipeline,
+                             inputs=[uuid, pos_prompt, neg_prompt, base_model_index, user_model, num_images, lora_choice, style_model, multiplier_style, multiplier_human,
+                                     pose_model, pose_image],
+                             outputs=[infer_progress, output_images])
+        history_button.click(fn=deal_history,
+                             inputs=[uuid, base_model_index, user_model, lora_choice, style_model, load_history_text],
+                             outputs=[single_history, batch_history])
+        delete_history_button.click(fn=deal_history,
+                                    inputs=[uuid, base_model_index, user_model, lora_choice, style_model, delete_history_text],
+                                    outputs=[single_history, batch_history])
+
+    return demo
+
+def inference_inpaint():
+    preset_template = glob(os.path.join('resources/inpaint_template/*.jpg'))
+    with gr.Blocks() as demo:
+        uuid = gr.Text(label="modelscope_uuid", visible=False)
+        # Initialize the GUI
+
+        with gr.Row():
+            with gr.Column():
+                with gr.Box():
+                    gr.Markdown('请选择或上传模板图片(Please select or upload a template image)：')
+                    template_image_list = [[i] for idx, i in enumerate(preset_template)]
+                    print(template_image_list)
+                    template_image = gr.Image(source='upload', type='filepath', label='模板图片(Template image)')
+                    gr.Examples(template_image_list, inputs=[template_image], label='模板示例(Template examples)')
+
+                base_model_list = []
+                for base_model in base_models:
+                    base_model_list.append(base_model['name'])
+
+                base_model_index = gr.Radio(
+                    label="基模型选择(Base model list)",
+                    choices=base_model_list,
+                    type="index"
+                )
+
+                num_faces = gr.Number(minimum=1, maximum=2, value=1, precision=1, label='照片中的人脸数目(Number of Faces)')
+                with gr.Row():
+                    with gr.Column(scale=2):
+                        user_model_A = gr.Radio(label="第1个人物LoRA，按从左至右的顺序（1st Character LoRA，counting from left to right）", choices=[], type="value")
+                        user_model_B = gr.Radio(label="第2个人物LoRA，按从左至右的顺序（2nd Character LoRA，counting from left to right）", choices=[], type="value", visible=False)
+                    with gr.Column(scale=1):
+                        update_button = gr.Button('刷新人物LoRA列表(Refresh character LoRAs)')
+
+        display_button = gr.Button('开始生成(Start Generation)')
+        with gr.Box():
+            infer_progress = gr.Textbox(
+                label="生成(Generation Progress)",
+                value="No task currently",
+                interactive=False
+            )
+        with gr.Box():
+            gr.Markdown('生成结果(Generated Results)')
+            output_images = gr.Gallery(
+                label='输出(Output)',
+                show_label=False
+            ).style(columns=3, rows=2, height=600, object_fit="contain")
+
+        base_model_index.change(fn=update_output_model_inpaint,
+                                inputs=[uuid, base_model_index],
+                                outputs=[user_model_A, user_model_B],
+                                queue=False)
+
+        update_button.click(fn=update_output_model_inpaint,
+                            inputs=[uuid, base_model_index],
+                            outputs=[user_model_A, user_model_B],
+                            queue=False)
+
+        num_faces.change(fn=update_output_model_num,
+                                inputs=[num_faces],
+                                outputs=[user_model_A, user_model_B],
+                                queue=False)
+
+        display_button.click(
+            fn=launch_pipeline_inpaint,
+            inputs=[uuid, base_model_index, user_model_A, user_model_B, num_faces, template_image],
+            outputs=[infer_progress, output_images]
+        )
+
+    return demo
+
+with gr.Blocks(css='style.css') as demo:
+    gr.Markdown("# <center> \N{fire} FaceChain Potrait Generation ([Github star it here](https://github.com/modelscope/facechain/tree/main) \N{whale},   [Paper cite it here](https://arxiv.org/abs/2308.14256) \N{whale})</center>")
+    with gr.Tabs():
+        with gr.TabItem('\N{rocket}人物形象训练(Train Digital Twin)'):
+            train_input()
+        with gr.TabItem('\N{party popper}无限风格形象写真(Infinite Style Portrait)'):
+            inference_input()
+        with gr.TabItem('\N{party popper}固定模板形象写真(Fixed Templates Portrait)'):
+            inference_inpaint()
+
+if __name__ == "__main__":
+    multiprocessing.set_start_method('spawn')
+    demo.queue(status_update_rate=1).launch(share=True)

facechain/facechain/__init__.py

@@ -0,0 +1 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.

facechain/facechain/constants.py

@@ -0,0 +1,202 @@
+neg_prompt = 'nsfw, paintings, sketches, (worst quality:2), (low quality:2) ' \
+             'lowers, normal quality, ((monochrome)), ((grayscale)), logo, word, character'
+pos_prompt_with_cloth = 'raw photo, masterpiece, chinese, {}, solo, medium shot, high detail face, looking straight into the camera with shoulders parallel to the frame, slim body, photorealistic, best quality'
+pos_prompt_with_style = '{}, upper_body, raw photo, masterpiece, solo, medium shot, high detail face, slim body, photorealistic, best quality'
+
+base_models = [
+    {'name': 'leosamsMoonfilm_filmGrain20',
+    'model_id': 'ly261666/cv_portrait_model',
+    'revision': 'v2.0',
+    'sub_path': "film/film",
+    'style_list': ['工作服(Working suit)', '盔甲风(Armor)','T恤衫(T-shirt)','汉服风(Hanfu)','女士晚礼服(Gown)','赛博朋克(Cybernetics punk)','凤冠霞帔(Chinese traditional gorgeous suit)']},
+    {'name': 'MajicmixRealistic_v6',
+    'model_id': 'YorickHe/majicmixRealistic_v6',
+    'revision': 'v1.0.0',
+    'sub_path': "realistic",
+    'style_list': ['冬季汉服(Chinese winter hanfu)', '校服风(School uniform)', '婚纱风(Wedding dress)', '夜景港风(Hong Kong night style)', '雨夜(Rainy night)', '模特风(Model style)', '机车风(Motorcycle race style)', '婚纱风-2(Wedding dress 2)','拍立得风(Polaroid style)', '仙女风(Fairy style)', '古风(traditional chinese style)', '壮族服装风(Zhuang style)', '欧式田野风(European fields)']},
+]
+
+styles = [
+    {'name': '工作服(Working suit)',
+     'img': './style_image/Working_suit.jpg',
+     'model_id': None,
+     'revision': None,
+     'bin_file': None,
+     'multiplier_style': 0.35,
+     'multiplier_human': 0.95,
+     'add_prompt_style': 'wearing high-class business/working suit, simple background, high-class pure color background'},
+    {'name': '盔甲风(Armor)',
+     'img': './style_image/Armor.jpg',
+     'model_id': None,
+     'revision': None,
+     'bin_file': None,
+     'multiplier_style': 0.35,
+     'multiplier_human': 0.95,
+     'add_prompt_style': 'wearing silver armor, simple background, high-class pure color background'},
+    {'name': 'T恤衫(T-shirt)',
+     'img': './style_image/T-shirt.jpg',
+     'model_id': None,
+     'revision': None,
+     'bin_file': None,
+     'multiplier_style': 0.35,
+     'multiplier_human': 0.95,
+     'add_prompt_style': 'wearing T-shirt, simple background, high-class pure color background'},
+    {'name': '汉服风(Hanfu)',
+     'img': './style_image/Hanfu.jpg',
+     'model_id': None,
+     'revision': None,
+     'bin_file': None,
+     'multiplier_style': 0.35,
+     'multiplier_human': 0.95,
+     'add_prompt_style': 'wearing beautiful traditional hanfu, upper_body, simple background, high-class pure color background'},
+    {'name': '女士晚礼服(Gown)',
+     'img': './style_image/Gown.jpg',
+     'model_id': None,
+     'revision': None,
+     'bin_file': None,
+     'multiplier_style': 0.35,
+     'multiplier_human': 0.95,
+     'add_prompt_style': 'wearing an elegant evening gown, simple background, high-class pure color background'},
+    {'name': '赛博朋克(Cybernetics punk)',
+     'img': './style_image/Cybernetics_punk.jpg',
+     'model_id': None,
+     'revision': None,
+     'bin_file': None,
+     'multiplier_style': 0.35,
+     'multiplier_human': 0.95,
+     'add_prompt_style': 'white hair, neon glowing glasses, cybernetics, punks, robotic, AI, NFT art, Fluorescent color, ustration'},
+    {'name': '凤冠霞帔(Chinese traditional gorgeous suit)',
+     'img': './style_image/Chinese_traditional_gorgeous_suit.jpg',
+     'model_id': 'ly261666/civitai_xiapei_lora',
+     'revision': 'v1.0.0',
+     'bin_file': 'xiapei.safetensors',
+     'multiplier_style': 0.35,
+     'multiplier_human': 0.95,
+     'add_prompt_style': 'red, hanfu, tiara, crown'},
+     {'name': '冬季汉服(Chinese winter hanfu)',
+     'img': './style_image/Chinese_winter_hanfu.jpg',
+     'model_id': 'YorickHe/Winter_hanfu_lora',
+     'revision': 'v1.0.0',
+     'bin_file': 'Winter_Hanfu.safetensors',
+     'multiplier_style': 0.3,
+     'multiplier_human': 0.95,
+     'add_prompt_style': 'red hanfu, winter hanfu, cloak, photography, warm light, sunlight, majestic snow scene,  close-up, front view, soft falling snowflakes, jewelry, enchanted winter wonderland'},
+     {'name': '校服风(School uniform)',
+     'img': './style_image/School_uniform.jpg',
+     'model_id': 'YorickHe/JK_uniform_lora',
+     'revision': 'v1.0.0',
+     'bin_file': 'jk_uniform.safetensors',
+     'multiplier_style': 0.2,
+     'multiplier_human': 0.95,
+     'add_prompt_style': 'JK_style, white short-sleeved JK_shirt, dark blue JK_skirt, bow JK_tie, close-up, looking at viewer, sweet smile, night, Tokyo street, night city scape'},
+     {'name': '婚纱风(Wedding dress)',
+     'img': './style_image/Wedding_dress.jpg',
+     'model_id': 'YorickHe/outdoor_photo_lora',
+     'revision': 'v1.0.0',
+     'bin_file': 'outdoor_photo_v2.0.safetensors',
+     'multiplier_style': 0.3,
+     'multiplier_human': 0.95,
+     'add_prompt_style': 'white wedding dress, 1girl, summer, flower, happy atmosphere, sunlight, Waist Shot'},
+     {'name': '夜景港风(Hong Kong night style)',
+     'img': './style_image/Hong_Kong_night_style.jpg',
+     'model_id': 'YorickHe/polaroid_lora',
+     'revision': 'v1.0.0',
+     'bin_file': 'InstantPhotoX3.safetensors',
+     'multiplier_style': 0.35,
+     'multiplier_human': 0.95,
+     'add_prompt_style': '1girl, close-up, face shot, stylish outfit, fitted jeans, oversized jacket, fashionable accessories, cityscape backdrop, rooftop or high-rise balcony, dynamic composition, engaging pose, soft yet striking lighting, shallow depth of field, bokeh from city lights, naturally blurred background'},
+     {'name': '雨夜(Rainy night)',
+     'img': './style_image/Rainy_night.jpg',
+     'model_id': 'YorickHe/polaroid_lora',
+     'revision': 'v1.0.0',
+     'bin_file': 'InstantPhotoX3.safetensors',
+     'multiplier_style': 0.45,
+     'multiplier_human': 0.95,
+     'add_prompt_style': 'standing in the rain, wet, wet clothes, wet hair, face Shot, front view, close-up, cityscape, cold lighting, realistic, cinematic lighting, photon mapping, radiosity, physically-based rendering'},
+     {'name': '模特风(Model style)',
+     'img': './style_image/Model_style.jpg',
+     'model_id': 'YorickHe/polaroid_lora',
+     'revision': 'v1.0.0',
+     'bin_file': 'InstantPhotoX3.safetensors',
+     'multiplier_style': 0.3,
+     'multiplier_human': 0.95,
+     'add_prompt_style': '1girl, balenciaga, close-up, fashion, streets of new york, new york, modeling for Balenciaga, natural skin texture, dynamic pose, rouge, film grain'},
+     {'name': '机车风(Motorcycle race style)',
+     'img': './style_image/Motorcycle_race_style.jpg',
+     'model_id': 'YorickHe/polaroid_lora',
+     'revision': 'v1.0.0',
+     'bin_file': 'InstantPhotoX3.safetensors',
+     'multiplier_style': 0.4,
+     'multiplier_human': 0.95,
+     'add_prompt_style': '1girl, close-up, wearing racing clothes, motorbike clothes, modeling, playful, futuristic, city street background, at night, cool atmospheric, realistic'},
+     {'name': '婚纱风-2(Wedding dress 2)',
+     'img': './style_image/Wedding_dress_2.jpg',
+     'model_id': 'YorickHe/polaroid_lora',
+     'revision': 'v1.0.0',
+     'bin_file': 'InstantPhotoX3.safetensors',
+     'multiplier_style': 0.4,
+     'multiplier_human': 0.95,
+     'add_prompt_style': '1girl, close-up, wearing wedding dress, white, film grain, sunlight, sun flare, lens flare, field of white roses, high fashion, top model'},
+    {'name': '拍立得风(Polaroid style)',
+     'img': './style_image/Polaroid_style.jpg',
+     'model_id': 'YorickHe/polaroid_lora',
+     'revision': 'v1.0.0',
+     'bin_file': 'InstantPhotoX3.safetensors',
+     'multiplier_style': 0.4,
+     'multiplier_human': 0.95,
+     'add_prompt_style': '1girl, close-up, simple clothes, front view, looking straight into the camera, film grain, flash, enhanced flash, dark background, polaroid, instant photo, realistic face'},
+     {'name': '仙女风(Fairy style)',
+     'img': './style_image/Fairy_style.jpg',
+     'model_id': 'YorickHe/fairy_lora',
+     'revision': 'v1.0.0',
+     'bin_file': 'fairy.safetensors',
+     'multiplier_style': 0.25,
+     'multiplier_human': 0.95,
+     'add_prompt_style': 'a beautiful fairy standing in the middle of a flower field, petals, close-up, warm light, light green atmosphere, white atmosphere, in the style of celebrity photography, soft, romantic scenes, flowing fabrics, light white and light orange, high resolution'},
+     {'name': '古风(traditional chinese style)',
+     'img': './style_image/traditional_chinese_style.jpg',
+     'model_id': 'iotang/lora_testing',
+     'revision': 'v5',
+     'bin_file': 'MoXinV1.safetensors',
+     'multiplier_style': 0.3,
+     'multiplier_human': 0.95,
+     'add_prompt_style': '(ultra high res face, face ultra zoom, highres, best quality, ultra detailed, cinematic lighting, portrait, Chinese traditional ink painting:1.2), sfw, shuimobysim, song, anxiang, hanfu, Ultra HD, wuchangshuo, detailed background, looking at viewer, serenity, peace'},
+    {'name': '壮族服装风(Zhuang style)',
+     'img': './style_image/Zhuang_style.jpg',
+     'model_id': 'iotang/lora_testing',
+     'revision': 'v5',
+     'bin_file': 'zhuangnv.safetensors',
+     'multiplier_style': 0.7,
+     'multiplier_human': 0.95,
+     'add_prompt_style': '(masterpiece, ultra high res face, face ultra zoom, highres, best quality, ultra detailed, cinematic lighting, portrait:1.2), sfw, facing the camera with a smile, zhuangzunv, ornaments, jewelry, headwear, beautiful embroidery, floral print, marvelous design, ancient Chinese traditional clothing'},
+    {'name': '欧式田野风(European fields)',
+     'img': './style_image/European_fields.jpg',
+     'model_id': 'iotang/lora_testing',
+     'revision': 'v5',
+     'bin_file': 'edgEuropean_Vintage.safetensors',
+     'multiplier_style': 0.55,
+     'multiplier_human': 0.95,
+     'add_prompt_style': '(masterpiece, ultra high res face, face ultra zoom, highres, best quality, ultra detailed, detailed background, cinematic lighting, portrait:1.2), sfw, focused, edgEV, wearing edgEV_vintage dress, field, natural lighting, windy hair, gentle hair, clean'},
+    
+]
+
+pose_models = [
+    {'name': '无姿态控制(No pose control)'},
+    {'name': 'pose-v1.1-with-depth'},
+    {'name': 'pose-v1.1'}
+]
+
+pose_examples = {
+    'man': [
+        ['./poses/man/pose1.png'],
+        ['./poses/man/pose2.png'],
+        ['./poses/man/pose3.png'],
+        ['./poses/man/pose4.png']
+    ],
+    'woman': [
+        ['./poses/woman/pose1.png'],
+        ['./poses/woman/pose2.png'],
+        ['./poses/woman/pose3.png'],
+        ['./poses/woman/pose4.png'],
+    ]
+}

facechain/facechain/data_process/__init__.py

@@ -0,0 +1 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.

facechain/facechain/data_process/deepbooru.py

@@ -0,0 +1,796 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+
+import os
+import re
+
+from PIL import Image
+import numpy as np
+
+re_special = re.compile(r'([\\()])')
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from modelscope.hub.snapshot_download import snapshot_download
+
+# see https://github.com/AUTOMATIC1111/TorchDeepDanbooru for more
+LANCZOS = (Image.Resampling.LANCZOS if hasattr(Image, 'Resampling') else Image.LANCZOS)
+
+
+class DeepDanbooruModel(nn.Module):
+    def __init__(self):
+        super(DeepDanbooruModel, self).__init__()
+
+        self.tags = []
+
+        self.n_Conv_0 = nn.Conv2d(kernel_size=(7, 7), in_channels=3, out_channels=64, stride=(2, 2))
+        self.n_MaxPool_0 = nn.MaxPool2d(kernel_size=(3, 3), stride=(2, 2))
+        self.n_Conv_1 = nn.Conv2d(kernel_size=(1, 1), in_channels=64, out_channels=256)
+        self.n_Conv_2 = nn.Conv2d(kernel_size=(1, 1), in_channels=64, out_channels=64)
+        self.n_Conv_3 = nn.Conv2d(kernel_size=(3, 3), in_channels=64, out_channels=64)
+        self.n_Conv_4 = nn.Conv2d(kernel_size=(1, 1), in_channels=64, out_channels=256)
+        self.n_Conv_5 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=64)
+        self.n_Conv_6 = nn.Conv2d(kernel_size=(3, 3), in_channels=64, out_channels=64)
+        self.n_Conv_7 = nn.Conv2d(kernel_size=(1, 1), in_channels=64, out_channels=256)
+        self.n_Conv_8 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=64)
+        self.n_Conv_9 = nn.Conv2d(kernel_size=(3, 3), in_channels=64, out_channels=64)
+        self.n_Conv_10 = nn.Conv2d(kernel_size=(1, 1), in_channels=64, out_channels=256)
+        self.n_Conv_11 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=512, stride=(2, 2))
+        self.n_Conv_12 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=128)
+        self.n_Conv_13 = nn.Conv2d(kernel_size=(3, 3), in_channels=128, out_channels=128, stride=(2, 2))
+        self.n_Conv_14 = nn.Conv2d(kernel_size=(1, 1), in_channels=128, out_channels=512)
+        self.n_Conv_15 = nn.Conv2d(kernel_size=(1, 1), in_channels=512, out_channels=128)
+        self.n_Conv_16 = nn.Conv2d(kernel_size=(3, 3), in_channels=128, out_channels=128)
+        self.n_Conv_17 = nn.Conv2d(kernel_size=(1, 1), in_channels=128, out_channels=512)
+        self.n_Conv_18 = nn.Conv2d(kernel_size=(1, 1), in_channels=512, out_channels=128)
+        self.n_Conv_19 = nn.Conv2d(kernel_size=(3, 3), in_channels=128, out_channels=128)
+        self.n_Conv_20 = nn.Conv2d(kernel_size=(1, 1), in_channels=128, out_channels=512)
+        self.n_Conv_21 = nn.Conv2d(kernel_size=(1, 1), in_channels=512, out_channels=128)
+        self.n_Conv_22 = nn.Conv2d(kernel_size=(3, 3), in_channels=128, out_channels=128)
+        self.n_Conv_23 = nn.Conv2d(kernel_size=(1, 1), in_channels=128, out_channels=512)
+        self.n_Conv_24 = nn.Conv2d(kernel_size=(1, 1), in_channels=512, out_channels=128)
+        self.n_Conv_25 = nn.Conv2d(kernel_size=(3, 3), in_channels=128, out_channels=128)
+        self.n_Conv_26 = nn.Conv2d(kernel_size=(1, 1), in_channels=128, out_channels=512)
+        self.n_Conv_27 = nn.Conv2d(kernel_size=(1, 1), in_channels=512, out_channels=128)
+        self.n_Conv_28 = nn.Conv2d(kernel_size=(3, 3), in_channels=128, out_channels=128)
+        self.n_Conv_29 = nn.Conv2d(kernel_size=(1, 1), in_channels=128, out_channels=512)
+        self.n_Conv_30 = nn.Conv2d(kernel_size=(1, 1), in_channels=512, out_channels=128)
+        self.n_Conv_31 = nn.Conv2d(kernel_size=(3, 3), in_channels=128, out_channels=128)
+        self.n_Conv_32 = nn.Conv2d(kernel_size=(1, 1), in_channels=128, out_channels=512)
+        self.n_Conv_33 = nn.Conv2d(kernel_size=(1, 1), in_channels=512, out_channels=128)
+        self.n_Conv_34 = nn.Conv2d(kernel_size=(3, 3), in_channels=128, out_channels=128)
+        self.n_Conv_35 = nn.Conv2d(kernel_size=(1, 1), in_channels=128, out_channels=512)
+        self.n_Conv_36 = nn.Conv2d(kernel_size=(1, 1), in_channels=512, out_channels=1024, stride=(2, 2))
+        self.n_Conv_37 = nn.Conv2d(kernel_size=(1, 1), in_channels=512, out_channels=256)
+        self.n_Conv_38 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256, stride=(2, 2))
+        self.n_Conv_39 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_40 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_41 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_42 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_43 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_44 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_45 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_46 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_47 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_48 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_49 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_50 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_51 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_52 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_53 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_54 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_55 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_56 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_57 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_58 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_59 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_60 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_61 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_62 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_63 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_64 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_65 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_66 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_67 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_68 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_69 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_70 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_71 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_72 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_73 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_74 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_75 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_76 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_77 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_78 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_79 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_80 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_81 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_82 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_83 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_84 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_85 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_86 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_87 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_88 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_89 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_90 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_91 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_92 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_93 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_94 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_95 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_96 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_97 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_98 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256, stride=(2, 2))
+        self.n_Conv_99 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_100 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=1024, stride=(2, 2))
+        self.n_Conv_101 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_102 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_103 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_104 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_105 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_106 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_107 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_108 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_109 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_110 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_111 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_112 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_113 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_114 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_115 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_116 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_117 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_118 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_119 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_120 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_121 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_122 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_123 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_124 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_125 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_126 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_127 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_128 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_129 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_130 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_131 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_132 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_133 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_134 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_135 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_136 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_137 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_138 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_139 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_140 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_141 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_142 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_143 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_144 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_145 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_146 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_147 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_148 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_149 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_150 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_151 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_152 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_153 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_154 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_155 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=256)
+        self.n_Conv_156 = nn.Conv2d(kernel_size=(3, 3), in_channels=256, out_channels=256)
+        self.n_Conv_157 = nn.Conv2d(kernel_size=(1, 1), in_channels=256, out_channels=1024)
+        self.n_Conv_158 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=2048, stride=(2, 2))
+        self.n_Conv_159 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=512)
+        self.n_Conv_160 = nn.Conv2d(kernel_size=(3, 3), in_channels=512, out_channels=512, stride=(2, 2))
+        self.n_Conv_161 = nn.Conv2d(kernel_size=(1, 1), in_channels=512, out_channels=2048)
+        self.n_Conv_162 = nn.Conv2d(kernel_size=(1, 1), in_channels=2048, out_channels=512)
+        self.n_Conv_163 = nn.Conv2d(kernel_size=(3, 3), in_channels=512, out_channels=512)
+        self.n_Conv_164 = nn.Conv2d(kernel_size=(1, 1), in_channels=512, out_channels=2048)
+        self.n_Conv_165 = nn.Conv2d(kernel_size=(1, 1), in_channels=2048, out_channels=512)
+        self.n_Conv_166 = nn.Conv2d(kernel_size=(3, 3), in_channels=512, out_channels=512)
+        self.n_Conv_167 = nn.Conv2d(kernel_size=(1, 1), in_channels=512, out_channels=2048)
+        self.n_Conv_168 = nn.Conv2d(kernel_size=(1, 1), in_channels=2048, out_channels=4096, stride=(2, 2))
+        self.n_Conv_169 = nn.Conv2d(kernel_size=(1, 1), in_channels=2048, out_channels=1024)
+        self.n_Conv_170 = nn.Conv2d(kernel_size=(3, 3), in_channels=1024, out_channels=1024, stride=(2, 2))
+        self.n_Conv_171 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=4096)
+        self.n_Conv_172 = nn.Conv2d(kernel_size=(1, 1), in_channels=4096, out_channels=1024)
+        self.n_Conv_173 = nn.Conv2d(kernel_size=(3, 3), in_channels=1024, out_channels=1024)
+        self.n_Conv_174 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=4096)
+        self.n_Conv_175 = nn.Conv2d(kernel_size=(1, 1), in_channels=4096, out_channels=1024)
+        self.n_Conv_176 = nn.Conv2d(kernel_size=(3, 3), in_channels=1024, out_channels=1024)
+        self.n_Conv_177 = nn.Conv2d(kernel_size=(1, 1), in_channels=1024, out_channels=4096)
+        self.n_Conv_178 = nn.Conv2d(kernel_size=(1, 1), in_channels=4096, out_channels=9176, bias=False)
+
+    def forward(self, *inputs):
+        t_358, = inputs
+        t_359 = t_358.permute(*[0, 3, 1, 2])
+        t_359_padded = F.pad(t_359, [2, 3, 2, 3], value=0)
+        # t_360 = self.n_Conv_0(t_359_padded.to(self.n_Conv_0.bias.dtype) if devices.unet_needs_upcast else t_359_padded)
+        t_360 = self.n_Conv_0(t_359_padded.to(self.n_Conv_0.bias.dtype))
+        t_361 = F.relu(t_360)
+        t_361 = F.pad(t_361, [0, 1, 0, 1], value=float('-inf'))
+        t_362 = self.n_MaxPool_0(t_361)
+        t_363 = self.n_Conv_1(t_362)
+        t_364 = self.n_Conv_2(t_362)
+        t_365 = F.relu(t_364)
+        t_365_padded = F.pad(t_365, [1, 1, 1, 1], value=0)
+        t_366 = self.n_Conv_3(t_365_padded)
+        t_367 = F.relu(t_366)
+        t_368 = self.n_Conv_4(t_367)
+        t_369 = torch.add(t_368, t_363)
+        t_370 = F.relu(t_369)
+        t_371 = self.n_Conv_5(t_370)
+        t_372 = F.relu(t_371)
+        t_372_padded = F.pad(t_372, [1, 1, 1, 1], value=0)
+        t_373 = self.n_Conv_6(t_372_padded)
+        t_374 = F.relu(t_373)
+        t_375 = self.n_Conv_7(t_374)
+        t_376 = torch.add(t_375, t_370)
+        t_377 = F.relu(t_376)
+        t_378 = self.n_Conv_8(t_377)
+        t_379 = F.relu(t_378)
+        t_379_padded = F.pad(t_379, [1, 1, 1, 1], value=0)
+        t_380 = self.n_Conv_9(t_379_padded)
+        t_381 = F.relu(t_380)
+        t_382 = self.n_Conv_10(t_381)
+        t_383 = torch.add(t_382, t_377)
+        t_384 = F.relu(t_383)
+        t_385 = self.n_Conv_11(t_384)
+        t_386 = self.n_Conv_12(t_384)
+        t_387 = F.relu(t_386)
+        t_387_padded = F.pad(t_387, [0, 1, 0, 1], value=0)
+        t_388 = self.n_Conv_13(t_387_padded)
+        t_389 = F.relu(t_388)
+        t_390 = self.n_Conv_14(t_389)
+        t_391 = torch.add(t_390, t_385)
+        t_392 = F.relu(t_391)
+        t_393 = self.n_Conv_15(t_392)
+        t_394 = F.relu(t_393)
+        t_394_padded = F.pad(t_394, [1, 1, 1, 1], value=0)
+        t_395 = self.n_Conv_16(t_394_padded)
+        t_396 = F.relu(t_395)
+        t_397 = self.n_Conv_17(t_396)
+        t_398 = torch.add(t_397, t_392)
+        t_399 = F.relu(t_398)
+        t_400 = self.n_Conv_18(t_399)
+        t_401 = F.relu(t_400)
+        t_401_padded = F.pad(t_401, [1, 1, 1, 1], value=0)
+        t_402 = self.n_Conv_19(t_401_padded)
+        t_403 = F.relu(t_402)
+        t_404 = self.n_Conv_20(t_403)
+        t_405 = torch.add(t_404, t_399)
+        t_406 = F.relu(t_405)
+        t_407 = self.n_Conv_21(t_406)
+        t_408 = F.relu(t_407)
+        t_408_padded = F.pad(t_408, [1, 1, 1, 1], value=0)
+        t_409 = self.n_Conv_22(t_408_padded)
+        t_410 = F.relu(t_409)
+        t_411 = self.n_Conv_23(t_410)
+        t_412 = torch.add(t_411, t_406)
+        t_413 = F.relu(t_412)
+        t_414 = self.n_Conv_24(t_413)
+        t_415 = F.relu(t_414)
+        t_415_padded = F.pad(t_415, [1, 1, 1, 1], value=0)
+        t_416 = self.n_Conv_25(t_415_padded)
+        t_417 = F.relu(t_416)
+        t_418 = self.n_Conv_26(t_417)
+        t_419 = torch.add(t_418, t_413)
+        t_420 = F.relu(t_419)
+        t_421 = self.n_Conv_27(t_420)
+        t_422 = F.relu(t_421)
+        t_422_padded = F.pad(t_422, [1, 1, 1, 1], value=0)
+        t_423 = self.n_Conv_28(t_422_padded)
+        t_424 = F.relu(t_423)
+        t_425 = self.n_Conv_29(t_424)
+        t_426 = torch.add(t_425, t_420)
+        t_427 = F.relu(t_426)
+        t_428 = self.n_Conv_30(t_427)
+        t_429 = F.relu(t_428)
+        t_429_padded = F.pad(t_429, [1, 1, 1, 1], value=0)
+        t_430 = self.n_Conv_31(t_429_padded)
+        t_431 = F.relu(t_430)
+        t_432 = self.n_Conv_32(t_431)
+        t_433 = torch.add(t_432, t_427)
+        t_434 = F.relu(t_433)
+        t_435 = self.n_Conv_33(t_434)
+        t_436 = F.relu(t_435)
+        t_436_padded = F.pad(t_436, [1, 1, 1, 1], value=0)
+        t_437 = self.n_Conv_34(t_436_padded)
+        t_438 = F.relu(t_437)
+        t_439 = self.n_Conv_35(t_438)
+        t_440 = torch.add(t_439, t_434)
+        t_441 = F.relu(t_440)
+        t_442 = self.n_Conv_36(t_441)
+        t_443 = self.n_Conv_37(t_441)
+        t_444 = F.relu(t_443)
+        t_444_padded = F.pad(t_444, [0, 1, 0, 1], value=0)
+        t_445 = self.n_Conv_38(t_444_padded)
+        t_446 = F.relu(t_445)
+        t_447 = self.n_Conv_39(t_446)
+        t_448 = torch.add(t_447, t_442)
+        t_449 = F.relu(t_448)
+        t_450 = self.n_Conv_40(t_449)
+        t_451 = F.relu(t_450)
+        t_451_padded = F.pad(t_451, [1, 1, 1, 1], value=0)
+        t_452 = self.n_Conv_41(t_451_padded)
+        t_453 = F.relu(t_452)
+        t_454 = self.n_Conv_42(t_453)
+        t_455 = torch.add(t_454, t_449)
+        t_456 = F.relu(t_455)
+        t_457 = self.n_Conv_43(t_456)
+        t_458 = F.relu(t_457)
+        t_458_padded = F.pad(t_458, [1, 1, 1, 1], value=0)
+        t_459 = self.n_Conv_44(t_458_padded)
+        t_460 = F.relu(t_459)
+        t_461 = self.n_Conv_45(t_460)
+        t_462 = torch.add(t_461, t_456)
+        t_463 = F.relu(t_462)
+        t_464 = self.n_Conv_46(t_463)
+        t_465 = F.relu(t_464)
+        t_465_padded = F.pad(t_465, [1, 1, 1, 1], value=0)
+        t_466 = self.n_Conv_47(t_465_padded)
+        t_467 = F.relu(t_466)
+        t_468 = self.n_Conv_48(t_467)
+        t_469 = torch.add(t_468, t_463)
+        t_470 = F.relu(t_469)
+        t_471 = self.n_Conv_49(t_470)
+        t_472 = F.relu(t_471)
+        t_472_padded = F.pad(t_472, [1, 1, 1, 1], value=0)
+        t_473 = self.n_Conv_50(t_472_padded)
+        t_474 = F.relu(t_473)
+        t_475 = self.n_Conv_51(t_474)
+        t_476 = torch.add(t_475, t_470)
+        t_477 = F.relu(t_476)
+        t_478 = self.n_Conv_52(t_477)
+        t_479 = F.relu(t_478)
+        t_479_padded = F.pad(t_479, [1, 1, 1, 1], value=0)
+        t_480 = self.n_Conv_53(t_479_padded)
+        t_481 = F.relu(t_480)
+        t_482 = self.n_Conv_54(t_481)
+        t_483 = torch.add(t_482, t_477)
+        t_484 = F.relu(t_483)
+        t_485 = self.n_Conv_55(t_484)
+        t_486 = F.relu(t_485)
+        t_486_padded = F.pad(t_486, [1, 1, 1, 1], value=0)
+        t_487 = self.n_Conv_56(t_486_padded)
+        t_488 = F.relu(t_487)
+        t_489 = self.n_Conv_57(t_488)
+        t_490 = torch.add(t_489, t_484)
+        t_491 = F.relu(t_490)
+        t_492 = self.n_Conv_58(t_491)
+        t_493 = F.relu(t_492)
+        t_493_padded = F.pad(t_493, [1, 1, 1, 1], value=0)
+        t_494 = self.n_Conv_59(t_493_padded)
+        t_495 = F.relu(t_494)
+        t_496 = self.n_Conv_60(t_495)
+        t_497 = torch.add(t_496, t_491)
+        t_498 = F.relu(t_497)
+        t_499 = self.n_Conv_61(t_498)
+        t_500 = F.relu(t_499)
+        t_500_padded = F.pad(t_500, [1, 1, 1, 1], value=0)
+        t_501 = self.n_Conv_62(t_500_padded)
+        t_502 = F.relu(t_501)
+        t_503 = self.n_Conv_63(t_502)
+        t_504 = torch.add(t_503, t_498)
+        t_505 = F.relu(t_504)
+        t_506 = self.n_Conv_64(t_505)
+        t_507 = F.relu(t_506)
+        t_507_padded = F.pad(t_507, [1, 1, 1, 1], value=0)
+        t_508 = self.n_Conv_65(t_507_padded)
+        t_509 = F.relu(t_508)
+        t_510 = self.n_Conv_66(t_509)
+        t_511 = torch.add(t_510, t_505)
+        t_512 = F.relu(t_511)
+        t_513 = self.n_Conv_67(t_512)
+        t_514 = F.relu(t_513)
+        t_514_padded = F.pad(t_514, [1, 1, 1, 1], value=0)
+        t_515 = self.n_Conv_68(t_514_padded)
+        t_516 = F.relu(t_515)
+        t_517 = self.n_Conv_69(t_516)
+        t_518 = torch.add(t_517, t_512)
+        t_519 = F.relu(t_518)
+        t_520 = self.n_Conv_70(t_519)
+        t_521 = F.relu(t_520)
+        t_521_padded = F.pad(t_521, [1, 1, 1, 1], value=0)
+        t_522 = self.n_Conv_71(t_521_padded)
+        t_523 = F.relu(t_522)
+        t_524 = self.n_Conv_72(t_523)
+        t_525 = torch.add(t_524, t_519)
+        t_526 = F.relu(t_525)
+        t_527 = self.n_Conv_73(t_526)
+        t_528 = F.relu(t_527)
+        t_528_padded = F.pad(t_528, [1, 1, 1, 1], value=0)
+        t_529 = self.n_Conv_74(t_528_padded)
+        t_530 = F.relu(t_529)
+        t_531 = self.n_Conv_75(t_530)
+        t_532 = torch.add(t_531, t_526)
+        t_533 = F.relu(t_532)
+        t_534 = self.n_Conv_76(t_533)
+        t_535 = F.relu(t_534)
+        t_535_padded = F.pad(t_535, [1, 1, 1, 1], value=0)
+        t_536 = self.n_Conv_77(t_535_padded)
+        t_537 = F.relu(t_536)
+        t_538 = self.n_Conv_78(t_537)
+        t_539 = torch.add(t_538, t_533)
+        t_540 = F.relu(t_539)
+        t_541 = self.n_Conv_79(t_540)
+        t_542 = F.relu(t_541)
+        t_542_padded = F.pad(t_542, [1, 1, 1, 1], value=0)
+        t_543 = self.n_Conv_80(t_542_padded)
+        t_544 = F.relu(t_543)
+        t_545 = self.n_Conv_81(t_544)
+        t_546 = torch.add(t_545, t_540)
+        t_547 = F.relu(t_546)
+        t_548 = self.n_Conv_82(t_547)
+        t_549 = F.relu(t_548)
+        t_549_padded = F.pad(t_549, [1, 1, 1, 1], value=0)
+        t_550 = self.n_Conv_83(t_549_padded)
+        t_551 = F.relu(t_550)
+        t_552 = self.n_Conv_84(t_551)
+        t_553 = torch.add(t_552, t_547)
+        t_554 = F.relu(t_553)
+        t_555 = self.n_Conv_85(t_554)
+        t_556 = F.relu(t_555)
+        t_556_padded = F.pad(t_556, [1, 1, 1, 1], value=0)
+        t_557 = self.n_Conv_86(t_556_padded)
+        t_558 = F.relu(t_557)
+        t_559 = self.n_Conv_87(t_558)
+        t_560 = torch.add(t_559, t_554)
+        t_561 = F.relu(t_560)
+        t_562 = self.n_Conv_88(t_561)
+        t_563 = F.relu(t_562)
+        t_563_padded = F.pad(t_563, [1, 1, 1, 1], value=0)
+        t_564 = self.n_Conv_89(t_563_padded)
+        t_565 = F.relu(t_564)
+        t_566 = self.n_Conv_90(t_565)
+        t_567 = torch.add(t_566, t_561)
+        t_568 = F.relu(t_567)
+        t_569 = self.n_Conv_91(t_568)
+        t_570 = F.relu(t_569)
+        t_570_padded = F.pad(t_570, [1, 1, 1, 1], value=0)
+        t_571 = self.n_Conv_92(t_570_padded)
+        t_572 = F.relu(t_571)
+        t_573 = self.n_Conv_93(t_572)
+        t_574 = torch.add(t_573, t_568)
+        t_575 = F.relu(t_574)
+        t_576 = self.n_Conv_94(t_575)
+        t_577 = F.relu(t_576)
+        t_577_padded = F.pad(t_577, [1, 1, 1, 1], value=0)
+        t_578 = self.n_Conv_95(t_577_padded)
+        t_579 = F.relu(t_578)
+        t_580 = self.n_Conv_96(t_579)
+        t_581 = torch.add(t_580, t_575)
+        t_582 = F.relu(t_581)
+        t_583 = self.n_Conv_97(t_582)
+        t_584 = F.relu(t_583)
+        t_584_padded = F.pad(t_584, [0, 1, 0, 1], value=0)
+        t_585 = self.n_Conv_98(t_584_padded)
+        t_586 = F.relu(t_585)
+        t_587 = self.n_Conv_99(t_586)
+        t_588 = self.n_Conv_100(t_582)
+        t_589 = torch.add(t_587, t_588)
+        t_590 = F.relu(t_589)
+        t_591 = self.n_Conv_101(t_590)
+        t_592 = F.relu(t_591)
+        t_592_padded = F.pad(t_592, [1, 1, 1, 1], value=0)
+        t_593 = self.n_Conv_102(t_592_padded)
+        t_594 = F.relu(t_593)
+        t_595 = self.n_Conv_103(t_594)
+        t_596 = torch.add(t_595, t_590)
+        t_597 = F.relu(t_596)
+        t_598 = self.n_Conv_104(t_597)
+        t_599 = F.relu(t_598)
+        t_599_padded = F.pad(t_599, [1, 1, 1, 1], value=0)
+        t_600 = self.n_Conv_105(t_599_padded)
+        t_601 = F.relu(t_600)
+        t_602 = self.n_Conv_106(t_601)
+        t_603 = torch.add(t_602, t_597)
+        t_604 = F.relu(t_603)
+        t_605 = self.n_Conv_107(t_604)
+        t_606 = F.relu(t_605)
+        t_606_padded = F.pad(t_606, [1, 1, 1, 1], value=0)
+        t_607 = self.n_Conv_108(t_606_padded)
+        t_608 = F.relu(t_607)
+        t_609 = self.n_Conv_109(t_608)
+        t_610 = torch.add(t_609, t_604)
+        t_611 = F.relu(t_610)
+        t_612 = self.n_Conv_110(t_611)
+        t_613 = F.relu(t_612)
+        t_613_padded = F.pad(t_613, [1, 1, 1, 1], value=0)
+        t_614 = self.n_Conv_111(t_613_padded)
+        t_615 = F.relu(t_614)
+        t_616 = self.n_Conv_112(t_615)
+        t_617 = torch.add(t_616, t_611)
+        t_618 = F.relu(t_617)
+        t_619 = self.n_Conv_113(t_618)
+        t_620 = F.relu(t_619)
+        t_620_padded = F.pad(t_620, [1, 1, 1, 1], value=0)
+        t_621 = self.n_Conv_114(t_620_padded)
+        t_622 = F.relu(t_621)
+        t_623 = self.n_Conv_115(t_622)
+        t_624 = torch.add(t_623, t_618)
+        t_625 = F.relu(t_624)
+        t_626 = self.n_Conv_116(t_625)
+        t_627 = F.relu(t_626)
+        t_627_padded = F.pad(t_627, [1, 1, 1, 1], value=0)
+        t_628 = self.n_Conv_117(t_627_padded)
+        t_629 = F.relu(t_628)
+        t_630 = self.n_Conv_118(t_629)
+        t_631 = torch.add(t_630, t_625)
+        t_632 = F.relu(t_631)
+        t_633 = self.n_Conv_119(t_632)
+        t_634 = F.relu(t_633)
+        t_634_padded = F.pad(t_634, [1, 1, 1, 1], value=0)
+        t_635 = self.n_Conv_120(t_634_padded)
+        t_636 = F.relu(t_635)
+        t_637 = self.n_Conv_121(t_636)
+        t_638 = torch.add(t_637, t_632)
+        t_639 = F.relu(t_638)
+        t_640 = self.n_Conv_122(t_639)
+        t_641 = F.relu(t_640)
+        t_641_padded = F.pad(t_641, [1, 1, 1, 1], value=0)
+        t_642 = self.n_Conv_123(t_641_padded)
+        t_643 = F.relu(t_642)
+        t_644 = self.n_Conv_124(t_643)
+        t_645 = torch.add(t_644, t_639)
+        t_646 = F.relu(t_645)
+        t_647 = self.n_Conv_125(t_646)
+        t_648 = F.relu(t_647)
+        t_648_padded = F.pad(t_648, [1, 1, 1, 1], value=0)
+        t_649 = self.n_Conv_126(t_648_padded)
+        t_650 = F.relu(t_649)
+        t_651 = self.n_Conv_127(t_650)
+        t_652 = torch.add(t_651, t_646)
+        t_653 = F.relu(t_652)
+        t_654 = self.n_Conv_128(t_653)
+        t_655 = F.relu(t_654)
+        t_655_padded = F.pad(t_655, [1, 1, 1, 1], value=0)
+        t_656 = self.n_Conv_129(t_655_padded)
+        t_657 = F.relu(t_656)
+        t_658 = self.n_Conv_130(t_657)
+        t_659 = torch.add(t_658, t_653)
+        t_660 = F.relu(t_659)
+        t_661 = self.n_Conv_131(t_660)
+        t_662 = F.relu(t_661)
+        t_662_padded = F.pad(t_662, [1, 1, 1, 1], value=0)
+        t_663 = self.n_Conv_132(t_662_padded)
+        t_664 = F.relu(t_663)
+        t_665 = self.n_Conv_133(t_664)
+        t_666 = torch.add(t_665, t_660)
+        t_667 = F.relu(t_666)
+        t_668 = self.n_Conv_134(t_667)
+        t_669 = F.relu(t_668)
+        t_669_padded = F.pad(t_669, [1, 1, 1, 1], value=0)
+        t_670 = self.n_Conv_135(t_669_padded)
+        t_671 = F.relu(t_670)
+        t_672 = self.n_Conv_136(t_671)
+        t_673 = torch.add(t_672, t_667)
+        t_674 = F.relu(t_673)
+        t_675 = self.n_Conv_137(t_674)
+        t_676 = F.relu(t_675)
+        t_676_padded = F.pad(t_676, [1, 1, 1, 1], value=0)
+        t_677 = self.n_Conv_138(t_676_padded)
+        t_678 = F.relu(t_677)
+        t_679 = self.n_Conv_139(t_678)
+        t_680 = torch.add(t_679, t_674)
+        t_681 = F.relu(t_680)
+        t_682 = self.n_Conv_140(t_681)
+        t_683 = F.relu(t_682)
+        t_683_padded = F.pad(t_683, [1, 1, 1, 1], value=0)
+        t_684 = self.n_Conv_141(t_683_padded)
+        t_685 = F.relu(t_684)
+        t_686 = self.n_Conv_142(t_685)
+        t_687 = torch.add(t_686, t_681)
+        t_688 = F.relu(t_687)
+        t_689 = self.n_Conv_143(t_688)
+        t_690 = F.relu(t_689)
+        t_690_padded = F.pad(t_690, [1, 1, 1, 1], value=0)
+        t_691 = self.n_Conv_144(t_690_padded)
+        t_692 = F.relu(t_691)
+        t_693 = self.n_Conv_145(t_692)
+        t_694 = torch.add(t_693, t_688)
+        t_695 = F.relu(t_694)
+        t_696 = self.n_Conv_146(t_695)
+        t_697 = F.relu(t_696)
+        t_697_padded = F.pad(t_697, [1, 1, 1, 1], value=0)
+        t_698 = self.n_Conv_147(t_697_padded)
+        t_699 = F.relu(t_698)
+        t_700 = self.n_Conv_148(t_699)
+        t_701 = torch.add(t_700, t_695)
+        t_702 = F.relu(t_701)
+        t_703 = self.n_Conv_149(t_702)
+        t_704 = F.relu(t_703)
+        t_704_padded = F.pad(t_704, [1, 1, 1, 1], value=0)
+        t_705 = self.n_Conv_150(t_704_padded)
+        t_706 = F.relu(t_705)
+        t_707 = self.n_Conv_151(t_706)
+        t_708 = torch.add(t_707, t_702)
+        t_709 = F.relu(t_708)
+        t_710 = self.n_Conv_152(t_709)
+        t_711 = F.relu(t_710)
+        t_711_padded = F.pad(t_711, [1, 1, 1, 1], value=0)
+        t_712 = self.n_Conv_153(t_711_padded)
+        t_713 = F.relu(t_712)
+        t_714 = self.n_Conv_154(t_713)
+        t_715 = torch.add(t_714, t_709)
+        t_716 = F.relu(t_715)
+        t_717 = self.n_Conv_155(t_716)
+        t_718 = F.relu(t_717)
+        t_718_padded = F.pad(t_718, [1, 1, 1, 1], value=0)
+        t_719 = self.n_Conv_156(t_718_padded)
+        t_720 = F.relu(t_719)
+        t_721 = self.n_Conv_157(t_720)
+        t_722 = torch.add(t_721, t_716)
+        t_723 = F.relu(t_722)
+        t_724 = self.n_Conv_158(t_723)
+        t_725 = self.n_Conv_159(t_723)
+        t_726 = F.relu(t_725)
+        t_726_padded = F.pad(t_726, [0, 1, 0, 1], value=0)
+        t_727 = self.n_Conv_160(t_726_padded)
+        t_728 = F.relu(t_727)
+        t_729 = self.n_Conv_161(t_728)
+        t_730 = torch.add(t_729, t_724)
+        t_731 = F.relu(t_730)
+        t_732 = self.n_Conv_162(t_731)
+        t_733 = F.relu(t_732)
+        t_733_padded = F.pad(t_733, [1, 1, 1, 1], value=0)
+        t_734 = self.n_Conv_163(t_733_padded)
+        t_735 = F.relu(t_734)
+        t_736 = self.n_Conv_164(t_735)
+        t_737 = torch.add(t_736, t_731)
+        t_738 = F.relu(t_737)
+        t_739 = self.n_Conv_165(t_738)
+        t_740 = F.relu(t_739)
+        t_740_padded = F.pad(t_740, [1, 1, 1, 1], value=0)
+        t_741 = self.n_Conv_166(t_740_padded)
+        t_742 = F.relu(t_741)
+        t_743 = self.n_Conv_167(t_742)
+        t_744 = torch.add(t_743, t_738)
+        t_745 = F.relu(t_744)
+        t_746 = self.n_Conv_168(t_745)
+        t_747 = self.n_Conv_169(t_745)
+        t_748 = F.relu(t_747)
+        t_748_padded = F.pad(t_748, [0, 1, 0, 1], value=0)
+        t_749 = self.n_Conv_170(t_748_padded)
+        t_750 = F.relu(t_749)
+        t_751 = self.n_Conv_171(t_750)
+        t_752 = torch.add(t_751, t_746)
+        t_753 = F.relu(t_752)
+        t_754 = self.n_Conv_172(t_753)
+        t_755 = F.relu(t_754)
+        t_755_padded = F.pad(t_755, [1, 1, 1, 1], value=0)
+        t_756 = self.n_Conv_173(t_755_padded)
+        t_757 = F.relu(t_756)
+        t_758 = self.n_Conv_174(t_757)
+        t_759 = torch.add(t_758, t_753)
+        t_760 = F.relu(t_759)
+        t_761 = self.n_Conv_175(t_760)
+        t_762 = F.relu(t_761)
+        t_762_padded = F.pad(t_762, [1, 1, 1, 1], value=0)
+        t_763 = self.n_Conv_176(t_762_padded)
+        t_764 = F.relu(t_763)
+        t_765 = self.n_Conv_177(t_764)
+        t_766 = torch.add(t_765, t_760)
+        t_767 = F.relu(t_766)
+        t_768 = self.n_Conv_178(t_767)
+        t_769 = F.avg_pool2d(t_768, kernel_size=t_768.shape[-2:])
+        t_770 = torch.squeeze(t_769, 3)
+        t_770 = torch.squeeze(t_770, 2)
+        t_771 = torch.sigmoid(t_770)
+        return t_771
+
+    def load_state_dict(self, state_dict, **kwargs):
+        self.tags = state_dict.get('tags', [])
+
+        super(DeepDanbooruModel, self).load_state_dict({k: v for k, v in state_dict.items() if k != 'tags'})
+
+
+def resize_image(im, width, height):
+    ratio = width / height
+    src_ratio = im.width / im.height
+
+    src_w = width if ratio < src_ratio else im.width * height // im.height
+    src_h = height if ratio >= src_ratio else im.height * width // im.width
+
+    resized = im.resize((src_w, src_h), resample=LANCZOS)
+    res = Image.new("RGB", (width, height))
+    res.paste(resized, box=(width // 2 - src_w // 2, height // 2 - src_h // 2))
+
+    if ratio < src_ratio:
+        fill_height = height // 2 - src_h // 2
+        res.paste(resized.resize((width, fill_height), box=(0, 0, width, 0)), box=(0, 0))
+        res.paste(resized.resize((width, fill_height), box=(0, resized.height, width, resized.height)),
+                  box=(0, fill_height + src_h))
+    elif ratio > src_ratio:
+        fill_width = width // 2 - src_w // 2
+        res.paste(resized.resize((fill_width, height), box=(0, 0, 0, height)), box=(0, 0))
+        res.paste(resized.resize((fill_width, height), box=(resized.width, 0, resized.width, height)),
+                  box=(fill_width + src_w, 0))
+
+    return res
+
+
+class DeepDanbooru:
+    def __init__(self):
+        self.model = DeepDanbooruModel()
+
+        foundation_model_id = 'ly261666/cv_portrait_model'
+        snapshot_path = snapshot_download(foundation_model_id, revision='v4.0')
+        pretrain_model_path = os.path.join(snapshot_path, 'model-resnet_custom_v3.pt')
+
+        self.model.load_state_dict(torch.load(pretrain_model_path, map_location="cpu"))
+        self.model.eval()
+        self.model.to(torch.float16)
+
+    def start(self):
+        self.model.cuda()
+
+    def stop(self):
+        self.model.cpu()
+        torch.cuda.empty_cache()
+        torch.cuda.ipc_collect()
+
+    def tag(self, pil_image):
+        threshold = 0.5
+        use_spaces = False
+        use_escape = True
+        alpha_sort = True
+        include_ranks = False
+
+        pic = resize_image(pil_image.convert("RGB"), 512, 512)
+        a = np.expand_dims(np.array(pic, dtype=np.float32), 0) / 255
+
+        with torch.no_grad(), torch.autocast("cuda"):
+            x = torch.from_numpy(a).cuda()
+            y = self.model(x)[0].detach().cpu().numpy()
+
+        probability_dict = {}
+
+        for tag, probability in zip(self.model.tags, y):
+            if probability < threshold:
+                continue
+
+            if tag.startswith("rating:"):
+                continue
+
+            probability_dict[tag] = probability
+
+        if alpha_sort:
+            tags = sorted(probability_dict)
+        else:
+            tags = [tag for tag, _ in sorted(probability_dict.items(), key=lambda x: -x[1])]
+
+        res = []
+
+        for tag in [x for x in tags]:
+            probability = probability_dict[tag]
+            tag_outformat = tag
+            if use_spaces:
+                tag_outformat = tag_outformat.replace('_', ' ')
+            if use_escape:
+                tag_outformat = re.sub(re_special, r'\\\1', tag_outformat)
+            if include_ranks:
+                tag_outformat = f"({tag_outformat}:{probability:.3f})"
+
+            res.append(tag_outformat)
+
+        return ", ".join(res)
+
+
+'''
+model = DeepDanbooru()
+impath = 'lyf'
+imlist = os.listdir(impath)
+result_list = []
+for im in imlist:
+    if im[-4:]=='.png':
+        print(im)
+        img = Image.open(os.path.join(impath, im))
+        result = model.tag(img)
+        print(result)
+        result_list.append(result)
+model.stop()
+'''

facechain/facechain/data_process/preprocessing.py

@@ -0,0 +1,355 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+
+import json
+import math
+import os
+import shutil
+
+import cv2
+import numpy as np
+from modelscope.outputs import OutputKeys
+from modelscope.pipelines import pipeline
+from modelscope.utils.constant import Tasks
+from PIL import Image
+from tqdm import tqdm
+
+from .deepbooru import DeepDanbooru
+
+
+
+def crop_and_resize(im, bbox):
+    h, w, _ = im.shape
+    thre = 0.35/1.15
+    maxf = max(bbox[2] - bbox[0], bbox[3] - bbox[1])
+    cx = (bbox[2] + bbox[0]) / 2
+    cy = (bbox[3] + bbox[1]) / 2
+    lenp = int(maxf / thre)
+    yc = 0.5/1.15
+    xc = 0.5
+    xmin = int(cx - xc * lenp)
+    xmax = xmin + lenp
+    ymin = int(cy - yc * lenp)
+    ymax = ymin + lenp
+    x1 = 0
+    x2 = lenp
+    y1 = 0
+    y2 = lenp
+    if xmin < 0:
+        x1 = -xmin
+        xmin = 0
+    if xmax > w:
+        x2 = w - (xmax - lenp)
+        xmax = w
+    if ymin < 0:
+        y1 = -ymin
+        ymin = 0
+    if ymax > h:
+        y2 = h - (ymax - lenp)
+        ymax = h
+    imc = (np.ones((lenp, lenp, 3)) * 255).astype(np.uint8)
+    imc[y1:y2, x1:x2, :] = im[ymin:ymax, xmin:xmax, :]
+    imr = cv2.resize(imc, (512, 512))
+    return imr
+
+
+def pad_to_square(im):
+    h, w, _ = im.shape
+    ns = int(max(h, w) * 1.5)
+    im = cv2.copyMakeBorder(im, int((ns - h) / 2), (ns - h) - int((ns - h) / 2), int((ns - w) / 2),
+                            (ns - w) - int((ns - w) / 2), cv2.BORDER_CONSTANT, 255)
+    return im
+
+
+def post_process_naive(result_list, score_gender, score_age):
+    # determine trigger word
+    gender = np.argmax(score_gender)
+    age = np.argmax(score_age)
+    if age < 2:
+        if gender == 0:
+            tag_a_g = ['a boy', 'children']
+        else:
+            tag_a_g = ['a girl', 'children']
+    elif age > 4:
+        if gender == 0:
+            tag_a_g = ['a mature man']
+        else:
+            tag_a_g = ['a mature woman']
+    else:
+        if gender == 0:
+            tag_a_g = ['a handsome man']
+        else:
+            tag_a_g = ['a beautiful woman']
+    num_images = len(result_list)
+    cnt_girl = 0
+    cnt_boy = 0
+    result_list_new = []
+    for result in result_list:
+        result_new = []
+        result_new.extend(tag_a_g)
+        ## don't include other infos for lora training
+        #for tag in result:
+        #    if tag == '1girl' or tag == '1boy':
+        #        continue
+        #    if tag[-4:] == '_man':
+        #        continue
+        #    if tag[-6:] == '_woman':
+        #        continue
+        #    if tag[-5:] == '_male':
+        #        continue
+        #    elif tag[-7:] == '_female':
+        #        continue
+        #    elif (
+        #            tag == 'ears' or tag == 'head' or tag == 'face' or tag == 'lips' or tag == 'mouth' or tag == '3d' or tag == 'asian' or tag == 'teeth'):
+        #        continue
+        #    elif ('eye' in tag and not 'eyewear' in tag):
+        #        continue
+        #    elif ('nose' in tag or 'body' in tag):
+        #        continue
+        #    elif tag[-5:] == '_lips':
+        #        continue
+        #    else:
+        #        result_new.append(tag)
+        #    # import pdb;pdb.set_trace()
+        ## result_new.append('slim body')
+        result_list_new.append(result_new)
+
+    return result_list_new
+
+
+def transformation_from_points(points1, points2):
+    points1 = points1.astype(np.float64)
+    points2 = points2.astype(np.float64)
+    c1 = np.mean(points1, axis=0)
+    c2 = np.mean(points2, axis=0)
+    points1 -= c1
+    points2 -= c2
+    s1 = np.std(points1)
+    s2 = np.std(points2)
+    if s1 < 1.0e-4:
+        s1 = 1.0e-4
+    points1 /= s1
+    points2 /= s2
+    U, S, Vt = np.linalg.svd(points1.T * points2)
+    R = (U * Vt).T
+    return np.vstack([np.hstack(((s2 / s1) * R, c2.T - (s2 / s1) * R * c1.T)), np.matrix([0., 0., 1.])])
+
+
+def rotate(im, keypoints):
+    h, w, _ = im.shape
+    points_array = np.zeros((5, 2))
+    dst_mean_face_size = 160
+    dst_mean_face = np.asarray([0.31074522411511746, 0.2798131190011913,
+                                0.6892073313037804, 0.2797830232679366,
+                                0.49997367716346774, 0.5099309118810921,
+                                0.35811903020866753, 0.7233174007629063,
+                                0.6418878095835022, 0.7232890570786875])
+    dst_mean_face = np.reshape(dst_mean_face, (5, 2)) * dst_mean_face_size
+
+    for k in range(5):
+        points_array[k, 0] = keypoints[2 * k]
+        points_array[k, 1] = keypoints[2 * k + 1]
+
+    pts1 = np.float64(np.matrix([[point[0], point[1]] for point in points_array]))
+    pts2 = np.float64(np.matrix([[point[0], point[1]] for point in dst_mean_face]))
+    trans_mat = transformation_from_points(pts1, pts2)
+    if trans_mat[1, 1] > 1.0e-4:
+        angle = math.atan(trans_mat[1, 0] / trans_mat[1, 1])
+    else:
+        angle = math.atan(trans_mat[0, 1] / trans_mat[0, 2])
+    im = pad_to_square(im)
+    ns = int(1.5 * max(h, w))
+    M = cv2.getRotationMatrix2D((ns / 2, ns / 2), angle=-angle / np.pi * 180, scale=1.0)
+    im = cv2.warpAffine(im, M=M, dsize=(ns, ns))
+    return im
+
+
+def get_mask_head(result):
+    masks = result['masks']
+    scores = result['scores']
+    labels = result['labels']
+    mask_hair = np.zeros((512, 512))
+    mask_face = np.zeros((512, 512))
+    mask_human = np.zeros((512, 512))
+    for i in range(len(labels)):
+        if scores[i] > 0.8:
+            if labels[i] == 'Face':
+                if np.sum(masks[i]) > np.sum(mask_face):
+                    mask_face = masks[i]
+            elif labels[i] == 'Human':
+                if np.sum(masks[i]) > np.sum(mask_human):
+                    mask_human = masks[i]
+            elif labels[i] == 'Hair':
+                if np.sum(masks[i]) > np.sum(mask_hair):
+                    mask_hair = masks[i]
+    mask_head = np.clip(mask_hair + mask_face, 0, 1)
+    ksize = max(int(np.sqrt(np.sum(mask_face)) / 20), 1)
+    kernel = np.ones((ksize, ksize))
+    mask_head = cv2.dilate(mask_head, kernel, iterations=1) * mask_human
+    _, mask_head = cv2.threshold((mask_head * 255).astype(np.uint8), 127, 255, cv2.THRESH_BINARY)
+    contours, hierarchy = cv2.findContours(mask_head, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)
+    area = []
+    for j in range(len(contours)):
+        area.append(cv2.contourArea(contours[j]))
+    max_idx = np.argmax(area)
+    mask_head = np.zeros((512, 512)).astype(np.uint8)
+    cv2.fillPoly(mask_head, [contours[max_idx]], 255)
+    mask_head = mask_head.astype(np.float32) / 255
+    mask_head = np.clip(mask_head + mask_face, 0, 1)
+    mask_head = np.expand_dims(mask_head, 2)
+    return mask_head
+
+
+class Blipv2():
+    def __init__(self):
+        self.model = DeepDanbooru()
+        self.skin_retouching = pipeline('skin-retouching-torch', model='damo/cv_unet_skin_retouching_torch', model_revision='v1.0.1')
+        self.face_detection = pipeline(task=Tasks.face_detection, model='damo/cv_ddsar_face-detection_iclr23-damofd', model_revision='v1.1')
+        # self.mog_face_detection_func = pipeline(Tasks.face_detection, 'damo/cv_resnet101_face-detection_cvpr22papermogface')
+        self.segmentation_pipeline = pipeline(Tasks.image_segmentation,
+                                              'damo/cv_resnet101_image-multiple-human-parsing', model_revision='v1.0.1')
+        self.fair_face_attribute_func = pipeline(Tasks.face_attribute_recognition,
+                                                 'damo/cv_resnet34_face-attribute-recognition_fairface', model_revision='v2.0.2')
+        self.facial_landmark_confidence_func = pipeline(Tasks.face_2d_keypoints,
+                                                        'damo/cv_manual_facial-landmark-confidence_flcm', model_revision='v2.5')
+
+    def __call__(self, imdir):
+        self.model.start()
+        savedir = str(imdir) + '_labeled'
+        shutil.rmtree(savedir, ignore_errors=True)
+        os.makedirs(savedir, exist_ok=True)
+
+        imlist = os.listdir(imdir)
+        result_list = []
+        imgs_list = []
+
+        cnt = 0
+        tmp_path = os.path.join(savedir, 'tmp.png')
+        for imname in imlist:
+            try:
+                # if 1:
+                if imname.startswith('.'):
+                    continue
+                img_path = os.path.join(imdir, imname)
+                im = cv2.imread(img_path)
+                h, w, _ = im.shape
+                max_size = max(w, h)
+                ratio = 1024 / max_size
+                new_w = round(w * ratio)
+                new_h = round(h * ratio)
+                imt = cv2.resize(im, (new_w, new_h))
+                cv2.imwrite(tmp_path, imt)
+                result_det = self.face_detection(tmp_path)
+                bboxes = result_det['boxes']
+                if len(bboxes) > 1:
+                    areas = []
+                    for i in range(len(bboxes)):
+                        bbox = bboxes[i]
+                        areas.append((bbox[2] - bbox[0]) * (bbox[3] - bbox[1]))
+                    areas = np.array(areas)
+                    areas_new = np.sort(areas)[::-1]
+                    idxs = np.argsort(areas)[::-1]
+                    if areas_new[0] < 4 * areas_new[1]:
+                        print('Detecting multiple faces, do not use image {}.'.format(imname))
+                        continue
+                    else:
+                        keypoints = result_det['keypoints'][idxs[0]]
+                elif len(bboxes) == 0:
+                    print('Detecting no face, do not use image {}.'.format(imname))
+                    continue
+                else:
+                    keypoints = result_det['keypoints'][0]
+
+                im = rotate(im, keypoints)
+                ns = im.shape[0]
+                imt = cv2.resize(im, (1024, 1024))
+                cv2.imwrite(tmp_path, imt)
+                result_det = self.face_detection(tmp_path)
+                bboxes = result_det['boxes']
+
+                if len(bboxes) > 1:
+                    areas = []
+                    for i in range(len(bboxes)):
+                        bbox = bboxes[i]
+                        areas.append((bbox[2] - bbox[0]) * (bbox[3] - bbox[1]))
+                    areas = np.array(areas)
+                    areas_new = np.sort(areas)[::-1]
+                    idxs = np.argsort(areas)[::-1]
+                    if areas_new[0] < 4 * areas_new[1]:
+                        print('Detecting multiple faces after rotation, do not use image {}.'.format(imname))
+                        continue
+                    else:
+                        bbox = bboxes[idxs[0]]
+                elif len(bboxes) == 0:
+                    print('Detecting no face after rotation, do not use this image {}'.format(imname))
+                    continue
+                else:
+                    bbox = bboxes[0]
+
+                for idx in range(4):
+                    bbox[idx] = bbox[idx] * ns / 1024
+                imr = crop_and_resize(im, bbox)
+                cv2.imwrite(tmp_path, imr)
+
+                result = self.skin_retouching(tmp_path)
+                if (result is None or (result[OutputKeys.OUTPUT_IMG] is None)):
+                    print('Cannot do skin retouching, do not use this image.')
+                    continue
+                cv2.imwrite(tmp_path, result[OutputKeys.OUTPUT_IMG])
+
+                result = self.segmentation_pipeline(tmp_path)
+                mask_head = get_mask_head(result)
+                im = cv2.imread(tmp_path)
+                im = im * mask_head + 255 * (1 - mask_head)
+                # print(im.shape)
+
+                raw_result = self.facial_landmark_confidence_func(im)
+                if raw_result is None:
+                    print('landmark quality fail...')
+                    continue
+
+                print(imname, raw_result['scores'][0])
+                if float(raw_result['scores'][0]) < (1 - 0.145):
+                    print('landmark quality fail...')
+                    continue
+
+                cv2.imwrite(os.path.join(savedir, '{}.png'.format(cnt)), im)
+                imgs_list.append('{}.png'.format(cnt))
+                img = Image.open(os.path.join(savedir, '{}.png'.format(cnt)))
+                result = self.model.tag(img)
+                print(result)
+                attribute_result = self.fair_face_attribute_func(tmp_path)
+                if cnt == 0:
+                    score_gender = np.array(attribute_result['scores'][0])
+                    score_age = np.array(attribute_result['scores'][1])
+                else:
+                    score_gender += np.array(attribute_result['scores'][0])
+                    score_age += np.array(attribute_result['scores'][1])
+
+                result_list.append(result.split(', '))
+                cnt += 1
+            except Exception as e:
+                print('cathed for image process of ' + imname)
+                print(f'Error: {e}')
+
+        print(result_list)
+        if len(result_list) == 0:
+            print('Error: result is empty.')
+            exit()
+            # return os.path.join(savedir, "metadata.jsonl")
+
+        result_list = post_process_naive(result_list, score_gender, score_age)
+        self.model.stop()
+        try:
+            os.remove(tmp_path)
+        except OSError as e:
+            print(f"Failed to remove path {tmp_path}: {e}")
+
+        out_json_name = os.path.join(savedir, "metadata.jsonl")
+        fo = open(out_json_name, 'w')
+        for i in range(len(result_list)):
+            generated_text = ", ".join(result_list[i])
+            print(imgs_list[i], generated_text)
+            info_dict = {"file_name": imgs_list[i], "text": "<fcsks>, " + generated_text}
+            fo.write(json.dumps(info_dict) + '\n')
+        fo.close()
+        return out_json_name

facechain/facechain/inference.py

@@ -0,0 +1,530 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+import json
+import os
+
+import cv2
+import numpy as np
+import torch
+from PIL import Image
+from controlnet_aux import OpenposeDetector
+from diffusers import StableDiffusionPipeline, StableDiffusionControlNetPipeline, ControlNetModel, \
+    UniPCMultistepScheduler
+from facechain.utils import snapshot_download
+from modelscope.outputs import OutputKeys
+from modelscope.pipelines import pipeline
+from modelscope.utils.constant import Tasks
+from torch import multiprocessing
+from transformers import pipeline as tpipeline
+
+from facechain.data_process.preprocessing import Blipv2
+from facechain.merge_lora import merge_lora
+
+
+def _data_process_fn_process(input_img_dir):
+    Blipv2()(input_img_dir)
+
+
+def data_process_fn(input_img_dir, use_data_process):
+    ## TODO add face quality filter
+    if use_data_process:
+        ## TODO
+
+        _process = multiprocessing.Process(target=_data_process_fn_process, args=(input_img_dir,))
+        _process.start()
+        _process.join()
+
+    return os.path.join(str(input_img_dir) + '_labeled', "metadata.jsonl")
+
+def txt2img(pipe, pos_prompt, neg_prompt, num_images=10):
+    batch_size = 5
+    images_out = []
+    for i in range(int(num_images / batch_size)):
+        images_style = pipe(prompt=pos_prompt, height=512, width=512, guidance_scale=7, negative_prompt=neg_prompt,
+                            num_inference_steps=40, num_images_per_prompt=batch_size).images
+        images_out.extend(images_style)
+    return images_out
+
+def img_pad(pil_file, fixed_height=512, fixed_width=512):
+    w, h = pil_file.size
+
+    if h / float(fixed_height) >= w / float(fixed_width):
+        factor = h / float(fixed_height)
+        new_w = int(w / factor)
+        pil_file.thumbnail(size=(new_w, fixed_height))
+        pad_w = int((fixed_width - new_w) / 2)
+        pad_w1 = (fixed_width - new_w) - pad_w
+        array_file = np.array(pil_file)
+        array_file = np.pad(array_file, ((0, 0), (pad_w, pad_w1), (0, 0)), 'constant')
+    else:
+        factor = w / float(fixed_width)
+        new_h = int(h / factor)
+        pil_file.thumbnail(size=(fixed_width, new_h))
+        pad_h = fixed_height - new_h
+        pad_h1 = 0
+        array_file = np.array(pil_file)
+        array_file = np.pad(array_file, ((pad_h, pad_h1), (0, 0), (0, 0)), 'constant')
+
+    output_file = Image.fromarray(array_file)
+    return output_file
+
+def preprocess_pose(origin_img) -> Image:
+    img = Image.open(origin_img)
+    img = img_pad(img)
+    model_dir = snapshot_download('damo/face_chain_control_model',revision='v1.0.1')
+    openpose = OpenposeDetector.from_pretrained(os.path.join(model_dir, 'model_controlnet/ControlNet'))
+    result = openpose(img, include_hand=True, output_type='np')
+    # resize to original size
+    h, w = img.size
+    result = cv2.resize(result, (w, h))
+    return result
+
+def txt2img_pose(pipe, pose_im, pos_prompt, neg_prompt, num_images=10):
+    batch_size = 2
+    images_out = []
+    for i in range(int(num_images / batch_size)):
+        images_style = pipe(prompt=pos_prompt, image=pose_im, height=512, width=512, guidance_scale=7, negative_prompt=neg_prompt,
+                            num_inference_steps=40, num_images_per_prompt=batch_size).images
+        images_out.extend(images_style)
+    return images_out
+
+def txt2img_multi(pipe, images, pos_prompt, neg_prompt, num_images=10):
+    batch_size = 2
+    images_out = []
+    for i in range(int(num_images / batch_size)):
+        images_style = pipe(pos_prompt, images, height=512, width=512, guidance_scale=7, negative_prompt=neg_prompt, controlnet_conditioning_scale=[1.0, 0.5],
+                            num_inference_steps=40, num_images_per_prompt=batch_size).images
+        images_out.extend(images_style)
+    return images_out
+
+def get_mask(result):
+    masks = result['masks']
+    scores = result['scores']
+    labels = result['labels']
+    h, w = masks[0].shape
+    mask_hair = np.zeros((h, w))
+    mask_face = np.zeros((h, w))
+    mask_human = np.zeros((h, w))
+    for i in range(len(labels)):
+        if scores[i] > 0.8:
+            if labels[i] == 'Face':
+                if np.sum(masks[i]) > np.sum(mask_face):
+                    mask_face = masks[i]
+            elif labels[i] == 'Human':
+                if np.sum(masks[i]) > np.sum(mask_human):
+                    mask_human = masks[i]
+            elif labels[i] == 'Hair':
+                if np.sum(masks[i]) > np.sum(mask_hair):
+                    mask_hair = masks[i]
+    mask_rst = np.clip(mask_human - mask_hair - mask_face, 0, 1)
+    mask_rst = np.expand_dims(mask_rst, 2)
+    mask_rst = np.concatenate([mask_rst, mask_rst, mask_rst], axis=2)
+    return mask_rst
+
+def main_diffusion_inference(pos_prompt, neg_prompt,
+                             input_img_dir, base_model_path, style_model_path, lora_model_path,
+                             multiplier_style=0.25,
+                             multiplier_human=0.85):
+    if style_model_path is None:
+        model_dir = snapshot_download('Cherrytest/zjz_mj_jiyi_small_addtxt_fromleo', revision='v1.0.0')
+        style_model_path = os.path.join(model_dir, 'zjz_mj_jiyi_small_addtxt_fromleo.safetensors')
+
+    pipe = StableDiffusionPipeline.from_pretrained(base_model_path, safety_checker=None, torch_dtype=torch.float32)
+    lora_style_path = style_model_path
+    lora_human_path = lora_model_path
+    pipe = merge_lora(pipe, lora_style_path, multiplier_style, from_safetensor=True)
+    pipe = merge_lora(pipe, lora_human_path, multiplier_human, from_safetensor=lora_human_path.endswith('safetensors'))
+    print(f'multiplier_style:{multiplier_style}, multiplier_human:{multiplier_human}')
+    
+    train_dir = str(input_img_dir) + '_labeled'
+    add_prompt_style = []
+    f = open(os.path.join(train_dir, 'metadata.jsonl'), 'r')
+    tags_all = []
+    cnt = 0
+    cnts_trigger = np.zeros(6)
+    for line in f:
+        cnt += 1
+        data = json.loads(line)['text'].split(', ')
+        tags_all.extend(data)
+        if data[1] == 'a boy':
+            cnts_trigger[0] += 1
+        elif data[1] == 'a girl':
+            cnts_trigger[1] += 1
+        elif data[1] == 'a handsome man':
+            cnts_trigger[2] += 1
+        elif data[1] == 'a beautiful woman':
+            cnts_trigger[3] += 1
+        elif data[1] == 'a mature man':
+            cnts_trigger[4] += 1
+        elif data[1] == 'a mature woman':
+            cnts_trigger[5] += 1
+        else:
+            print('Error.')
+    f.close()
+
+    attr_idx = np.argmax(cnts_trigger)
+    trigger_styles = ['a boy, children, ', 'a girl, children, ', 'a handsome man, ', 'a beautiful woman, ',
+                      'a mature man, ', 'a mature woman, ']
+    trigger_style = '<fcsks>, ' + trigger_styles[attr_idx]
+    if attr_idx == 2 or attr_idx == 4:
+        neg_prompt += ', children'
+
+    for tag in tags_all:
+        if tags_all.count(tag) > 0.5 * cnt:
+            if ('hair' in tag or 'face' in tag or 'mouth' in tag or 'skin' in tag or 'smile' in tag):
+                if not tag in add_prompt_style:
+                    add_prompt_style.append(tag)
+
+
+    
+    if len(add_prompt_style) > 0:
+        add_prompt_style = ", ".join(add_prompt_style) + ', '
+    else:
+        add_prompt_style = ''
+
+    pipe = pipe.to("cuda")
+    images_style = txt2img(pipe, trigger_style + add_prompt_style + pos_prompt, neg_prompt, num_images=10)
+    return images_style
+
+def main_diffusion_inference_pose(pose_model_path, pose_image,
+                                  pos_prompt, neg_prompt,
+                                  input_img_dir, base_model_path, style_model_path, lora_model_path,
+                                  multiplier_style=0.25,
+                                  multiplier_human=0.85):
+    if style_model_path is None:
+        model_dir = snapshot_download('Cherrytest/zjz_mj_jiyi_small_addtxt_fromleo', revision='v1.0.0')
+        style_model_path = os.path.join(model_dir, 'zjz_mj_jiyi_small_addtxt_fromleo.safetensors')
+
+    controlnet = ControlNetModel.from_pretrained(pose_model_path, torch_dtype=torch.float32)
+    pipe = StableDiffusionControlNetPipeline.from_pretrained(base_model_path, safety_checker=None, controlnet=controlnet, torch_dtype=torch.float32)
+    pipe.scheduler = UniPCMultistepScheduler.from_config(pipe.scheduler.config)
+    pose_im = Image.open(pose_image)
+    pose_im = img_pad(pose_im)
+    model_dir = snapshot_download('damo/face_chain_control_model',revision='v1.0.1')
+    openpose = OpenposeDetector.from_pretrained(os.path.join(model_dir, 'model_controlnet/ControlNet'))
+    pose_im = openpose(pose_im, include_hand=True)
+
+    lora_style_path = style_model_path
+    lora_human_path = lora_model_path
+    pipe = merge_lora(pipe, lora_style_path, multiplier_style, from_safetensor=True)
+    pipe = merge_lora(pipe, lora_human_path, multiplier_human, from_safetensor=False)
+    print(f'multiplier_style:{multiplier_style}, multiplier_human:{multiplier_human}')
+    
+    train_dir = str(input_img_dir) + '_labeled'
+    add_prompt_style = []
+    f = open(os.path.join(train_dir, 'metadata.jsonl'), 'r')
+    tags_all = []
+    cnt = 0
+    cnts_trigger = np.zeros(6)
+    for line in f:
+        cnt += 1
+        data = json.loads(line)['text'].split(', ')
+        tags_all.extend(data)
+        if data[1] == 'a boy':
+            cnts_trigger[0] += 1
+        elif data[1] == 'a girl':
+            cnts_trigger[1] += 1
+        elif data[1] == 'a handsome man':
+            cnts_trigger[2] += 1
+        elif data[1] == 'a beautiful woman':
+            cnts_trigger[3] += 1
+        elif data[1] == 'a mature man':
+            cnts_trigger[4] += 1
+        elif data[1] == 'a mature woman':
+            cnts_trigger[5] += 1
+        else:
+            print('Error.')
+    f.close()
+
+    attr_idx = np.argmax(cnts_trigger)
+    trigger_styles = ['a boy, children, ', 'a girl, children, ', 'a handsome man, ', 'a beautiful woman, ',
+                      'a mature man, ', 'a mature woman, ']
+    trigger_style = '<fcsks>, ' + trigger_styles[attr_idx]
+    if attr_idx == 2 or attr_idx == 4:
+        neg_prompt += ', children'
+
+    for tag in tags_all:
+        if tags_all.count(tag) > 0.5 * cnt:
+            if ('hair' in tag or 'face' in tag or 'mouth' in tag or 'skin' in tag or 'smile' in tag):
+                if not tag in add_prompt_style:
+                    add_prompt_style.append(tag)
+
+    if len(add_prompt_style) > 0:
+        add_prompt_style = ", ".join(add_prompt_style) + ', '
+    else:
+        add_prompt_style = ''
+    # trigger_style = trigger_style + 'with <input_id> face, '
+    # pos_prompt = 'Generate a standard ID photo of a chinese {}, solo, wearing high-class business/working suit, beautiful smooth face, with high-class/simple pure color background, looking straight into the camera with shoulders parallel to the frame, smile, high detail face, best quality, photorealistic'.format(gender)
+    pipe = pipe.to("cuda")
+    # print(trigger_style + add_prompt_style + pos_prompt)
+    images_style = txt2img_pose(pipe, pose_im, trigger_style + add_prompt_style + pos_prompt, neg_prompt, num_images=10)
+    return images_style
+
+
+def main_diffusion_inference_multi(pose_model_path, pose_image,
+                                  pos_prompt, neg_prompt,
+                                  input_img_dir, base_model_path, style_model_path, lora_model_path,
+                                  multiplier_style=0.25,
+                                  multiplier_human=0.85):
+    if style_model_path is None:
+        model_dir = snapshot_download('Cherrytest/zjz_mj_jiyi_small_addtxt_fromleo', revision='v1.0.0')
+        style_model_path = os.path.join(model_dir, 'zjz_mj_jiyi_small_addtxt_fromleo.safetensors')
+
+    model_dir = snapshot_download('damo/face_chain_control_model', revision='v1.0.1')
+    controlnet = [
+        ControlNetModel.from_pretrained(pose_model_path, torch_dtype=torch.float32),
+        ControlNetModel.from_pretrained(os.path.join(model_dir, 'model_controlnet/control_v11p_sd15_depth'), torch_dtype=torch.float32)
+    ]
+    pipe = StableDiffusionControlNetPipeline.from_pretrained(base_model_path, safety_checker=None, controlnet=controlnet, torch_dtype=torch.float32)
+    pipe.scheduler = UniPCMultistepScheduler.from_config(pipe.scheduler.config)
+    pose_image = Image.open(pose_image)
+    pose_image = img_pad(pose_image)
+    openpose = OpenposeDetector.from_pretrained(os.path.join(model_dir, 'model_controlnet/ControlNet'))
+    pose_im = openpose(pose_image, include_hand=True)
+    segmentation_pipeline = pipeline(Tasks.image_segmentation,
+                                     'damo/cv_resnet101_image-multiple-human-parsing')
+    result = segmentation_pipeline(pose_image)
+    mask_rst = get_mask(result)
+    pose_image = np.array(pose_image)
+    pose_image = (pose_image * mask_rst).astype(np.uint8)
+    pose_image = Image.fromarray(pose_image)
+    depth_estimator = tpipeline('depth-estimation', os.path.join(model_dir, 'model_controlnet/dpt-large'))
+    depth_im = depth_estimator(pose_image)['depth']
+    depth_im = np.array(depth_im)
+    depth_im = depth_im[:, :, None]
+    depth_im = np.concatenate([depth_im, depth_im, depth_im], axis=2)
+    depth_im = Image.fromarray(depth_im)
+    control_im = [pose_im, depth_im]
+
+    lora_style_path = style_model_path
+    lora_human_path = lora_model_path
+    pipe = merge_lora(pipe, lora_style_path, multiplier_style, from_safetensor=True)
+    pipe = merge_lora(pipe, lora_human_path, multiplier_human, from_safetensor=False)
+    print(f'multiplier_style:{multiplier_style}, multiplier_human:{multiplier_human}')
+    
+    train_dir = str(input_img_dir) + '_labeled'
+    add_prompt_style = []
+    f = open(os.path.join(train_dir, 'metadata.jsonl'), 'r')
+    tags_all = []
+    cnt = 0
+    cnts_trigger = np.zeros(6)
+    for line in f:
+        cnt += 1
+        data = json.loads(line)['text'].split(', ')
+        tags_all.extend(data)
+        if data[1] == 'a boy':
+            cnts_trigger[0] += 1
+        elif data[1] == 'a girl':
+            cnts_trigger[1] += 1
+        elif data[1] == 'a handsome man':
+            cnts_trigger[2] += 1
+        elif data[1] == 'a beautiful woman':
+            cnts_trigger[3] += 1
+        elif data[1] == 'a mature man':
+            cnts_trigger[4] += 1
+        elif data[1] == 'a mature woman':
+            cnts_trigger[5] += 1
+        else:
+            print('Error.')
+    f.close()
+
+    attr_idx = np.argmax(cnts_trigger)
+    trigger_styles = ['a boy, children, ', 'a girl, children, ', 'a handsome man, ', 'a beautiful woman, ',
+                      'a mature man, ', 'a mature woman, ']
+    trigger_style = '<fcsks>, ' + trigger_styles[attr_idx]
+    if attr_idx == 2 or attr_idx == 4:
+        neg_prompt += ', children'
+
+    for tag in tags_all:
+        if tags_all.count(tag) > 0.5 * cnt:
+            if ('hair' in tag or 'face' in tag or 'mouth' in tag or 'skin' in tag or 'smile' in tag):
+                if not tag in add_prompt_style:
+                    add_prompt_style.append(tag)
+
+    if len(add_prompt_style) > 0:
+        add_prompt_style = ", ".join(add_prompt_style) + ', '
+    else:
+        add_prompt_style = ''
+    # trigger_style = trigger_style + 'with <input_id> face, '
+    # pos_prompt = 'Generate a standard ID photo of a chinese {}, solo, wearing high-class business/working suit, beautiful smooth face, with high-class/simple pure color background, looking straight into the camera with shoulders parallel to the frame, smile, high detail face, best quality, photorealistic'.format(gender)
+    pipe = pipe.to("cuda")
+    # print(trigger_style + add_prompt_style + pos_prompt)
+    images_style = txt2img_multi(pipe, control_im, trigger_style + add_prompt_style + pos_prompt, neg_prompt, num_images=10)
+    return images_style
+
+def stylization_fn(use_stylization, rank_results):
+    if use_stylization:
+        ## TODO
+        pass
+    else:
+        return rank_results
+
+
+def main_model_inference(pose_model_path, pose_image, use_depth_control, pos_prompt, neg_prompt, style_model_path, multiplier_style, multiplier_human, use_main_model,
+                         input_img_dir=None, base_model_path=None, lora_model_path=None):
+    if use_main_model:
+        multiplier_style_kwargs = {'multiplier_style': multiplier_style} if multiplier_style is not None else {}
+        multiplier_human_kwargs = {'multiplier_human': multiplier_human} if multiplier_human is not None else {}
+        if pose_image is None:
+            return main_diffusion_inference(pos_prompt, neg_prompt, input_img_dir, base_model_path,
+                                            style_model_path, lora_model_path,
+                                            **multiplier_style_kwargs, **multiplier_human_kwargs)
+        else:
+            pose_image = compress_image(pose_image, 1024 * 1024)
+            if use_depth_control:
+                return main_diffusion_inference_multi(pose_model_path, pose_image, pos_prompt,
+                                                      neg_prompt, input_img_dir, base_model_path, style_model_path,
+                                                      lora_model_path,
+                                                      **multiplier_style_kwargs, **multiplier_human_kwargs)
+            else:
+                return main_diffusion_inference_pose(pose_model_path, pose_image, pos_prompt, neg_prompt,
+                                                     input_img_dir, base_model_path, style_model_path, lora_model_path,
+                                                     **multiplier_style_kwargs, **multiplier_human_kwargs)
+
+
+def select_high_quality_face(input_img_dir):
+    input_img_dir = str(input_img_dir) + '_labeled'
+    quality_score_list = []
+    abs_img_path_list = []
+    ## TODO
+    face_quality_func = pipeline(Tasks.face_quality_assessment, 'damo/cv_manual_face-quality-assessment_fqa', model_revision='v2.0')
+
+    for img_name in os.listdir(input_img_dir):
+        if img_name.endswith('jsonl') or img_name.startswith('.ipynb') or img_name.startswith('.safetensors'):
+            continue
+        
+        if img_name.endswith('jpg') or img_name.endswith('png'):
+            abs_img_name = os.path.join(input_img_dir, img_name)
+            face_quality_score = face_quality_func(abs_img_name)[OutputKeys.SCORES]
+            if face_quality_score is None:
+                quality_score_list.append(0)
+            else:
+                quality_score_list.append(face_quality_score[0])
+            abs_img_path_list.append(abs_img_name)
+
+    sort_idx = np.argsort(quality_score_list)[::-1]
+    print('Selected face: ' + abs_img_path_list[sort_idx[0]])
+
+    return Image.open(abs_img_path_list[sort_idx[0]])
+
+
+def face_swap_fn(use_face_swap, gen_results, template_face):
+    if use_face_swap:
+        ## TODO
+        out_img_list = []
+        image_face_fusion = pipeline('face_fusion_torch',
+                                     model='damo/cv_unet_face_fusion_torch', model_revision='v1.0.3')
+        for img in gen_results:
+            result = image_face_fusion(dict(template=img, user=template_face))[OutputKeys.OUTPUT_IMG]
+            out_img_list.append(result)
+
+        return out_img_list
+    else:
+        ret_results = []
+        for img in gen_results:
+            ret_results.append(cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR))
+        return ret_results
+
+
+def post_process_fn(use_post_process, swap_results_ori, selected_face, num_gen_images):
+    if use_post_process:
+        sim_list = []
+        ## TODO
+        face_recognition_func = pipeline(Tasks.face_recognition, 'damo/cv_ir_face-recognition-ood_rts', model_revision='v2.5')
+        face_det_func = pipeline(task=Tasks.face_detection, model='damo/cv_ddsar_face-detection_iclr23-damofd', model_revision='v1.1')
+        swap_results = []
+        for img in swap_results_ori:
+            result_det = face_det_func(img)
+            bboxes = result_det['boxes']
+            if len(bboxes) == 1:
+                bbox = bboxes[0]
+                lenface = max(bbox[2] - bbox[0], bbox[3] - bbox[1])
+                if 120 < lenface < 300:
+                    swap_results.append(img)
+
+        select_face_emb = face_recognition_func(selected_face)[OutputKeys.IMG_EMBEDDING][0]
+
+        for img in swap_results:
+            emb = face_recognition_func(img)[OutputKeys.IMG_EMBEDDING]
+            if emb is None or select_face_emb is None:
+                sim_list.append(0)
+            else:
+                sim = np.dot(emb, select_face_emb)
+                sim_list.append(sim.item())
+        sort_idx = np.argsort(sim_list)[::-1]
+
+        return np.array(swap_results)[sort_idx[:min(int(num_gen_images), len(swap_results))]]
+    else:
+        return np.array(swap_results_ori)
+
+
+class GenPortrait:
+    def __init__(self, pose_model_path, pose_image, use_depth_control, pos_prompt, neg_prompt, style_model_path, multiplier_style, multiplier_human,
+                 use_main_model=True, use_face_swap=True,
+                 use_post_process=True, use_stylization=True):
+        self.use_main_model = use_main_model
+        self.use_face_swap = use_face_swap
+        self.use_post_process = use_post_process
+        self.use_stylization = use_stylization
+        self.multiplier_style = multiplier_style
+        self.multiplier_human = multiplier_human
+        self.style_model_path = style_model_path
+        self.pos_prompt = pos_prompt
+        self.neg_prompt = neg_prompt
+        self.pose_model_path = pose_model_path
+        self.pose_image = pose_image
+        self.use_depth_control = use_depth_control
+
+    def __call__(self, input_img_dir, num_gen_images=6, base_model_path=None,
+                 lora_model_path=None, sub_path=None, revision=None):
+        base_model_path = snapshot_download(base_model_path, revision=revision)
+        if sub_path is not None and len(sub_path) > 0:
+            base_model_path = os.path.join(base_model_path, sub_path)
+
+        # main_model_inference PIL
+        gen_results = main_model_inference(self.pose_model_path, self.pose_image, self.use_depth_control,
+                                           self.pos_prompt, self.neg_prompt,
+                                           self.style_model_path, self.multiplier_style, self.multiplier_human,
+                                           self.use_main_model, input_img_dir=input_img_dir,
+                                           lora_model_path=lora_model_path, base_model_path=base_model_path)
+
+        # select_high_quality_face PIL
+        selected_face = select_high_quality_face(input_img_dir)
+        # face_swap cv2
+        swap_results = face_swap_fn(self.use_face_swap, gen_results, selected_face)
+        # pose_process
+        rank_results = post_process_fn(self.use_post_process, swap_results, selected_face,
+                                       num_gen_images=num_gen_images)
+        # stylization
+        final_gen_results = stylization_fn(self.use_stylization, rank_results)
+
+
+        return final_gen_results
+
+def compress_image(input_path, target_size):
+    output_path = change_extension_to_jpg(input_path)
+
+    image = cv2.imread(input_path)
+
+    quality = 95
+    try:
+        while cv2.imencode('.jpg', image, [cv2.IMWRITE_JPEG_QUALITY, quality])[1].size > target_size:
+            quality -= 5
+    except:
+        import pdb;pdb.set_trace()
+
+    compressed_image = cv2.imencode('.jpg', image, [cv2.IMWRITE_JPEG_QUALITY, quality])[1].tostring()
+
+    with open(output_path, 'wb') as f:
+        f.write(compressed_image)
+    return output_path
+
+
+def change_extension_to_jpg(image_path):
+
+    base_name = os.path.basename(image_path)
+    new_base_name = os.path.splitext(base_name)[0] + ".jpg"
+
+    directory = os.path.dirname(image_path)
+
+    new_image_path = os.path.join(directory, new_base_name)
+    return new_image_path

facechain/facechain/inference_inpaint.py

@@ -0,0 +1,890 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+# Modified from the original implementation at https://github.com/modelscope/facechain/pull/104.
+import json
+import os
+import sys
+
+import cv2
+import numpy as np
+import torch
+from PIL import Image
+from skimage import transform
+from controlnet_aux import OpenposeDetector
+from diffusers import StableDiffusionPipeline, StableDiffusionControlNetPipeline, \
+    StableDiffusionControlNetInpaintPipeline, ControlNetModel, UniPCMultistepScheduler
+from facechain.utils import snapshot_download
+from modelscope.outputs import OutputKeys
+from modelscope.pipelines import pipeline
+from modelscope.utils.constant import Tasks
+from torch import multiprocessing
+from transformers import pipeline as tpipeline
+
+from facechain.data_process.preprocessing import Blipv2
+from facechain.merge_lora import merge_lora
+
+
+def _data_process_fn_process(input_img_dir):
+    Blipv2()(input_img_dir)
+
+
+def concatenate_images(images):
+    heights = [img.shape[0] for img in images]
+    max_width = sum([img.shape[1] for img in images])
+
+    concatenated_image = np.zeros((max(heights), max_width, 3), dtype=np.uint8)
+    x_offset = 0
+    for img in images:
+        concatenated_image[0:img.shape[0], x_offset:x_offset + img.shape[1], :] = img
+        x_offset += img.shape[1]
+    return concatenated_image
+
+
+def data_process_fn(input_img_dir, use_data_process):
+    ## TODO add face quality filter
+    if use_data_process:
+        ## TODO
+
+        _process = multiprocessing.Process(target=_data_process_fn_process, args=(input_img_dir,))
+        _process.start()
+        _process.join()
+
+    return os.path.join(str(input_img_dir) + '_labeled', "metadata.jsonl")
+
+
+def call_face_crop(det_pipeline, image, crop_ratio):
+    det_result = det_pipeline(image)
+    bboxes = det_result['boxes']
+    keypoints = det_result['keypoints']
+    area = 0
+    idx = 0
+    for i in range(len(bboxes)):
+        bbox = bboxes[i]
+        area_tmp = (bbox[2] - bbox[0]) * (bbox[3] - bbox[1])
+        if area_tmp > area:
+            area = area_tmp
+            idx = i
+    bbox = bboxes[idx]
+    keypoint = keypoints[idx]
+    points_array = np.zeros((5, 2))
+    for k in range(5):
+        points_array[k, 0] = keypoint[2 * k]
+        points_array[k, 1] = keypoint[2 * k + 1]
+    w, h = image.size
+    face_w = bbox[2] - bbox[0]
+    face_h = bbox[3] - bbox[1]
+    bbox[0] = np.clip(np.array(bbox[0], np.int32) - face_w * (crop_ratio - 1) / 2, 0, w - 1)
+    bbox[1] = np.clip(np.array(bbox[1], np.int32) - face_h * (crop_ratio - 1) / 2, 0, h - 1)
+    bbox[2] = np.clip(np.array(bbox[2], np.int32) + face_w * (crop_ratio - 1) / 2, 0, w - 1)
+    bbox[3] = np.clip(np.array(bbox[3], np.int32) + face_h * (crop_ratio - 1) / 2, 0, h - 1)
+    bbox = np.array(bbox, np.int32)
+    return bbox, points_array
+
+
+def crop_and_paste(Source_image, Source_image_mask, Target_image, Source_Five_Point, Target_Five_Point, Source_box, use_warp=True):
+    if use_warp:
+        Source_Five_Point = np.reshape(Source_Five_Point, [5, 2]) - np.array(Source_box[:2])
+        Target_Five_Point = np.reshape(Target_Five_Point, [5, 2])
+
+        Crop_Source_image = Source_image.crop(np.int32(Source_box))
+        Crop_Source_image_mask = Source_image_mask.crop(np.int32(Source_box))
+        Source_Five_Point, Target_Five_Point = np.array(Source_Five_Point), np.array(Target_Five_Point)
+
+        tform = transform.SimilarityTransform()
+        tform.estimate(Source_Five_Point, Target_Five_Point)
+        M = tform.params[0:2, :]
+
+        warped = cv2.warpAffine(np.array(Crop_Source_image), M, np.shape(Target_image)[:2][::-1], borderValue=0.0)
+        warped_mask = cv2.warpAffine(np.array(Crop_Source_image_mask), M, np.shape(Target_image)[:2][::-1], borderValue=0.0)
+
+        mask = np.float32(warped_mask == 0)
+        output = mask * np.float32(Target_image) + (1 - mask) * np.float32(warped)
+    else:
+        mask = np.float32(np.array(Source_image_mask) == 0)
+        output = mask * np.float32(Target_image) + (1 - mask) * np.float32(Source_image)
+    return output, mask
+
+
+def segment(segmentation_pipeline, img, ksize=0, eyeh=0, ksize1=0, include_neck=False, warp_mask=None, return_human=False):
+    if True:
+        result = segmentation_pipeline(img)
+        masks = result['masks']
+        scores = result['scores']
+        labels = result['labels']
+        if len(masks) == 0:
+            return
+        h, w = masks[0].shape
+        mask_face = np.zeros((h, w))
+        mask_hair = np.zeros((h, w))
+        mask_neck = np.zeros((h, w))
+        mask_cloth = np.zeros((h, w))
+        mask_human = np.zeros((h, w))
+        for i in range(len(labels)):
+            if scores[i] > 0.8:
+                if labels[i] == 'Torso-skin':
+                    mask_neck += masks[i]
+                elif labels[i] == 'Face':
+                    mask_face += masks[i]
+                elif labels[i] == 'Human':
+                    mask_human += masks[i]
+                elif labels[i] == 'Hair':
+                    mask_hair += masks[i]
+                elif labels[i] == 'UpperClothes' or labels[i] == 'Coat':
+                    mask_cloth += masks[i]
+        mask_face = np.clip(mask_face, 0, 1)
+        mask_hair = np.clip(mask_hair, 0, 1)
+        mask_neck = np.clip(mask_neck, 0, 1)
+        mask_cloth = np.clip(mask_cloth, 0, 1)
+        mask_human = np.clip(mask_human, 0, 1)
+        if np.sum(mask_face) > 0:
+            soft_mask = np.clip(mask_face, 0, 1)
+            if ksize1 > 0:
+                kernel_size1 = int(np.sqrt(np.sum(soft_mask)) * ksize1)
+                kernel1 = np.ones((kernel_size1, kernel_size1))
+                soft_mask = cv2.dilate(soft_mask, kernel1, iterations=1)
+            if ksize > 0:
+                kernel_size = int(np.sqrt(np.sum(soft_mask)) * ksize)
+                kernel = np.ones((kernel_size, kernel_size))
+                soft_mask_dilate = cv2.dilate(soft_mask, kernel, iterations=1)
+                if warp_mask is not None:
+                    soft_mask_dilate = soft_mask_dilate * (np.clip(soft_mask + warp_mask[:, :, 0], 0, 1))
+                if eyeh > 0:
+                    soft_mask = np.concatenate((soft_mask[:eyeh], soft_mask_dilate[eyeh:]), axis=0)
+                else:
+                    soft_mask = soft_mask_dilate
+        else:
+            if ksize1 > 0:
+                kernel_size1 = int(np.sqrt(np.sum(soft_mask)) * ksize1)
+                kernel1 = np.ones((kernel_size1, kernel_size1))
+                soft_mask = cv2.dilate(mask_face, kernel1, iterations=1)
+            else:
+                soft_mask = mask_face
+        if include_neck:
+            soft_mask = np.clip(soft_mask + mask_neck, 0, 1)
+
+    if return_human:  
+        mask_human = cv2.GaussianBlur(mask_human, (21, 21), 0) * mask_human
+        return soft_mask, mask_human
+    else:
+        return soft_mask
+
+
+def crop_bottom(pil_file, width):
+    if width == 512:
+        height = 768
+    else:
+        height = 1152
+    w, h = pil_file.size
+    factor = w / width
+    new_h = int(h / factor)
+    pil_file = pil_file.resize((width, new_h))
+    crop_h = min(int(new_h / 32) * 32, height)
+    array_file = np.array(pil_file)
+    array_file = array_file[:crop_h, :, :]
+    output_file = Image.fromarray(array_file)
+    return output_file
+
+
+def img2img_multicontrol(img, control_image, controlnet_conditioning_scale, pipe, mask, pos_prompt, neg_prompt,
+                         strength, num=1, use_ori=False):
+    image_mask = Image.fromarray(np.uint8(mask * 255))
+    image_human = []
+    for i in range(num):
+        image_human.append(pipe(image=img, mask_image=image_mask, control_image=control_image, prompt=pos_prompt,
+                                negative_prompt=neg_prompt, guidance_scale=7, strength=strength, num_inference_steps=40,
+                                controlnet_conditioning_scale=controlnet_conditioning_scale,
+                                num_images_per_prompt=1).images[0])
+        if use_ori:
+            image_human[i] = Image.fromarray((np.array(image_human[i]) * mask[:,:,None] + np.array(img) * (1 - mask[:,:,None])).astype(np.uint8))
+    return image_human
+
+
+def get_mask(result):
+    masks = result['masks']
+    scores = result['scores']
+    labels = result['labels']
+    h, w = masks[0].shape
+    mask_hair = np.zeros((h, w))
+    mask_face = np.zeros((h, w))
+    mask_human = np.zeros((h, w))
+    for i in range(len(labels)):
+        if scores[i] > 0.8:
+            if labels[i] == 'Face':
+                if np.sum(masks[i]) > np.sum(mask_face):
+                    mask_face = masks[i]
+            elif labels[i] == 'Human':
+                if np.sum(masks[i]) > np.sum(mask_human):
+                    mask_human = masks[i]
+            elif labels[i] == 'Hair':
+                if np.sum(masks[i]) > np.sum(mask_hair):
+                    mask_hair = masks[i]
+    mask_rst = np.clip(mask_human - mask_hair - mask_face, 0, 1)
+    mask_rst = np.expand_dims(mask_rst, 2)
+    mask_rst = np.concatenate([mask_rst, mask_rst, mask_rst], axis=2)
+    return mask_rst
+
+
+def main_diffusion_inference_inpaint(inpaint_image, strength, output_img_size, pos_prompt, neg_prompt,
+                                     input_img_dir, base_model_path, style_model_path, lora_model_path,
+                                     multiplier_style=0.05,
+                                     multiplier_human=1.0):
+    if style_model_path is None:
+        model_dir = snapshot_download('Cherrytest/zjz_mj_jiyi_small_addtxt_fromleo', revision='v1.0.0')
+        style_model_path = os.path.join(model_dir, 'zjz_mj_jiyi_small_addtxt_fromleo.safetensors')
+
+    segmentation_pipeline = pipeline(Tasks.image_segmentation, 'damo/cv_resnet101_image-multiple-human-parsing')
+    det_pipeline = pipeline(Tasks.face_detection, 'damo/cv_ddsar_face-detection_iclr23-damofd')
+    model_dir = snapshot_download('damo/face_chain_control_model', revision='v1.0.1')
+    model_dir1 = snapshot_download('ly261666/cv_wanx_style_model',revision='v1.0.3')
+
+    if output_img_size == 512:
+        dtype = torch.float32
+    else:
+        dtype = torch.float16
+
+    train_dir = str(input_img_dir) + '_labeled'
+    add_prompt_style = []
+    f = open(os.path.join(train_dir, 'metadata.jsonl'), 'r')
+    tags_all = []
+    cnt = 0
+    cnts_trigger = np.zeros(6)
+    is_old = False
+    for line in f:
+        cnt += 1
+        data = json.loads(line)['text'].split(', ')
+        tags_all.extend(data)
+        if data[1] == 'a boy':
+            cnts_trigger[0] += 1
+        elif data[1] == 'a girl':
+            cnts_trigger[1] += 1
+        elif data[1] == 'a handsome man':
+            cnts_trigger[2] += 1
+        elif data[1] == 'a beautiful woman':
+            cnts_trigger[3] += 1
+        elif data[1] == 'a mature man':
+            cnts_trigger[4] += 1
+            is_old = True
+        elif data[1] == 'a mature woman':
+            cnts_trigger[5] += 1
+            is_old = True
+        else:
+            print('Error.')
+    f.close()
+
+    attr_idx = np.argmax(cnts_trigger)
+    trigger_styles = ['a boy, children, ', 'a girl, children, ', 'a handsome man, ', 'a beautiful woman, ',
+                      'a mature man, ', 'a mature woman, ']
+    trigger_style = '<fcsks>, ' + trigger_styles[attr_idx]
+    if attr_idx == 2 or attr_idx == 4:
+        neg_prompt += ', children'
+
+    for tag in tags_all:
+        if tags_all.count(tag) > 0.5 * cnt:
+            if ('glasses' in tag or 'smile' in tag):
+                if not tag in add_prompt_style:
+                    add_prompt_style.append(tag)
+
+    if len(add_prompt_style) > 0:
+        add_prompt_style = ", ".join(add_prompt_style) + ', '
+    else:
+        add_prompt_style = ''
+
+    if isinstance(inpaint_image, str): 
+        inpaint_im = Image.open(inpaint_image)
+    else:
+        inpaint_im = inpaint_image
+    inpaint_im = crop_bottom(inpaint_im, output_img_size)
+    # return [inpaint_im, inpaint_im, inpaint_im]
+    openpose = OpenposeDetector.from_pretrained(os.path.join(model_dir, "model_controlnet/ControlNet"))
+    controlnet = ControlNetModel.from_pretrained(os.path.join(model_dir, "model_controlnet/control_v11p_sd15_openpose"), torch_dtype=dtype)
+    openpose_image = openpose(np.array(inpaint_im, np.uint8), include_hand=True, include_face=False)
+    w, h = inpaint_im.size
+
+    pipe = StableDiffusionControlNetPipeline.from_pretrained(base_model_path, controlnet=controlnet, torch_dtype=dtype)
+    lora_style_path = style_model_path
+    lora_human_path = lora_model_path
+    pipe = merge_lora(pipe, lora_style_path, multiplier_style, from_safetensor=True)
+    pipe = merge_lora(pipe, lora_human_path, multiplier_human, from_safetensor=False)
+    pipe = pipe.to("cuda")
+    image_faces = []
+    for i in range(1):
+        image_face = pipe(prompt=trigger_style + add_prompt_style + pos_prompt, image=openpose_image, height=h, width=w,
+                          guidance_scale=7, negative_prompt=neg_prompt, 
+                          num_inference_steps=40, num_images_per_prompt=1).images[0]
+        image_faces.append(image_face)
+    selected_face = select_high_quality_face(input_img_dir)
+    swap_results = face_swap_fn(True, image_faces, selected_face)
+
+    controlnet = [
+        ControlNetModel.from_pretrained(os.path.join(model_dir, "model_controlnet/control_v11p_sd15_openpose"), torch_dtype=dtype),
+        ControlNetModel.from_pretrained(os.path.join(model_dir1, "contronet-canny"), torch_dtype=dtype)
+    ]
+    pipe = StableDiffusionControlNetInpaintPipeline.from_pretrained(base_model_path, controlnet=controlnet,
+                                                                    torch_dtype=dtype)
+    pipe.scheduler = UniPCMultistepScheduler.from_config(pipe.scheduler.config)
+    pipe = merge_lora(pipe, style_model_path, multiplier_style, from_safetensor=True)
+    pipe = merge_lora(pipe, lora_model_path, multiplier_human, from_safetensor=False)
+    pipe = pipe.to("cuda")
+
+    images_human = []
+    images_auto = []
+    inpaint_bbox, inpaint_keypoints = call_face_crop(det_pipeline, inpaint_im, 1.1)
+    eye_height = int((inpaint_keypoints[0, 1] + inpaint_keypoints[1, 1]) / 2)
+    canny_image = cv2.Canny(np.array(inpaint_im, np.uint8), 100, 200)[:, :, None]
+    mask = segment(segmentation_pipeline, inpaint_im, ksize=0.05, eyeh=eye_height)
+    canny_image = (canny_image * (1.0 - mask[:, :, None])).astype(np.uint8)
+    canny_image = Image.fromarray(np.concatenate([canny_image, canny_image, canny_image], axis=2))
+    # canny_image.save('canny.png')
+    for i in range(1):
+        image_face = swap_results[i]
+        image_face = Image.fromarray(image_face[:, :, ::-1])
+
+        face_bbox, face_keypoints = call_face_crop(det_pipeline, image_face, 1.5)
+        face_mask = segment(segmentation_pipeline, image_face)
+        face_mask = np.expand_dims((face_mask * 255).astype(np.uint8), axis=2)
+        face_mask = np.concatenate([face_mask, face_mask, face_mask], axis=2)
+        face_mask = Image.fromarray(face_mask)
+        replaced_input_image, warp_mask = crop_and_paste(image_face, face_mask, inpaint_im, face_keypoints,
+                                                         inpaint_keypoints, face_bbox)
+        warp_mask = 1.0 - warp_mask
+        # cv2.imwrite('tmp_{}.png'.format(i), replaced_input_image[:, :, ::-1])
+
+        openpose_image = openpose(np.array(replaced_input_image * warp_mask, np.uint8), include_hand=True,
+                                  include_body=False, include_face=True)
+        # openpose_image.save('openpose_{}.png'.format(i))
+        read_control = [openpose_image, canny_image]
+        inpaint_mask, human_mask = segment(segmentation_pipeline, inpaint_im, ksize=0.1, ksize1=0.06, eyeh=eye_height, include_neck=False,
+                               warp_mask=warp_mask, return_human=True)
+        inpaint_with_mask = ((1.0 - inpaint_mask[:,:,None]) * np.array(inpaint_im))[:,:,::-1]
+        # cv2.imwrite('inpaint_with_mask_{}.png'.format(i), inpaint_with_mask)
+        print('Finishing segmenting images.')
+        images_human.extend(img2img_multicontrol(inpaint_im, read_control, [1.0, 0.2], pipe, inpaint_mask,
+                                                 trigger_style + add_prompt_style + pos_prompt, neg_prompt,
+                                                 strength=strength))
+        images_auto.extend(img2img_multicontrol(inpaint_im, read_control, [1.0, 0.2], pipe, np.zeros_like(inpaint_mask),
+                                                 trigger_style + add_prompt_style + pos_prompt, neg_prompt,
+                                                 strength=0.025))
+    
+        edge_add = np.array(inpaint_im).astype(np.int16) - np.array(images_auto[i]).astype(np.int16)
+        edge_add = edge_add * (1 - human_mask[:,:,None])
+        images_human[i] = Image.fromarray((np.clip(np.array(images_human[i]).astype(np.int16) + edge_add.astype(np.int16), 0, 255)).astype(np.uint8))
+    
+    images_rst = []
+    
+    for i in range(len(images_human)):
+        im = images_human[i]
+        canny_image = cv2.Canny(np.array(im, np.uint8), 100, 200)[:, :, None]
+        canny_image = Image.fromarray(np.concatenate([canny_image, canny_image, canny_image], axis=2))
+        openpose_image = openpose(np.array(im, np.uint8), include_hand=True, include_face=True)
+        read_control = [openpose_image, canny_image]
+        inpaint_mask, human_mask = segment(segmentation_pipeline, images_human[i], ksize=0.02, return_human=True)
+        print('Finishing segmenting images.')
+        image_rst = img2img_multicontrol(im, read_control, [0.8, 0.8], pipe, inpaint_mask,
+                                         trigger_style + add_prompt_style + pos_prompt, neg_prompt, strength=0.1,
+                                         num=1)[0]
+        image_auto = img2img_multicontrol(im, read_control, [0.8, 0.8], pipe, np.zeros_like(inpaint_mask),
+                                         trigger_style + add_prompt_style + pos_prompt, neg_prompt, strength=0.025,
+                                         num=1)[0]
+        edge_add = np.array(im).astype(np.int16) - np.array(image_auto).astype(np.int16)
+        edge_add = edge_add * (1 - human_mask[:,:,None])
+        image_rst = Image.fromarray((np.clip(np.array(image_rst).astype(np.int16) + edge_add.astype(np.int16), 0, 255)).astype(np.uint8))
+        
+        images_rst.append(image_rst)
+
+    for i in range(1):
+        images_rst[i].save('inference_{}.png'.format(i))
+
+    return images_rst
+
+def main_diffusion_inference_inpaint_multi(inpaint_images, strength, output_img_size, pos_prompt, neg_prompt,
+                                     input_img_dir, base_model_path, style_model_path, lora_model_path,
+                                     multiplier_style=0.05,
+                                     multiplier_human=1.0):
+    if style_model_path is None:
+        model_dir = snapshot_download('Cherrytest/zjz_mj_jiyi_small_addtxt_fromleo', revision='v1.0.0')
+        style_model_path = os.path.join(model_dir, 'zjz_mj_jiyi_small_addtxt_fromleo.safetensors')
+
+    segmentation_pipeline = pipeline(Tasks.image_segmentation, 'damo/cv_resnet101_image-multiple-human-parsing')
+    det_pipeline = pipeline(Tasks.face_detection, 'damo/cv_ddsar_face-detection_iclr23-damofd')
+    model_dir = snapshot_download('damo/face_chain_control_model', revision='v1.0.1')
+    model_dir1 = snapshot_download('ly261666/cv_wanx_style_model',revision='v1.0.3')
+
+    if output_img_size == 512:
+        dtype = torch.float32
+    else:
+        dtype = torch.float16
+
+    train_dir = str(input_img_dir) + '_labeled'
+    add_prompt_style = []
+    f = open(os.path.join(train_dir, 'metadata.jsonl'), 'r')
+    tags_all = []
+    cnt = 0
+    cnts_trigger = np.zeros(6)
+    is_old = False
+    for line in f:
+        cnt += 1
+        data = json.loads(line)['text'].split(', ')
+        tags_all.extend(data)
+        if data[1] == 'a boy':
+            cnts_trigger[0] += 1
+        elif data[1] == 'a girl':
+            cnts_trigger[1] += 1
+        elif data[1] == 'a handsome man':
+            cnts_trigger[2] += 1
+        elif data[1] == 'a beautiful woman':
+            cnts_trigger[3] += 1
+        elif data[1] == 'a mature man':
+            cnts_trigger[4] += 1
+            is_old = True
+        elif data[1] == 'a mature woman':
+            cnts_trigger[5] += 1
+            is_old = True
+        else:
+            print('Error.')
+    f.close()
+
+    attr_idx = np.argmax(cnts_trigger)
+    trigger_styles = ['a boy, children, ', 'a girl, children, ', 'a handsome man, ', 'a beautiful woman, ',
+                      'a mature man, ', 'a mature woman, ']
+    trigger_style = '<fcsks>, ' + trigger_styles[attr_idx]
+    if attr_idx == 2 or attr_idx == 4:
+        neg_prompt += ', children'
+
+    for tag in tags_all:
+        if tags_all.count(tag) > 0.5 * cnt:
+            if ('glasses' in tag or 'smile' in tag):
+                if not tag in add_prompt_style:
+                    add_prompt_style.append(tag)
+
+    if len(add_prompt_style) > 0:
+        add_prompt_style = ", ".join(add_prompt_style) + ', '
+    else:
+        add_prompt_style = ''
+        
+    openpose = OpenposeDetector.from_pretrained(os.path.join(model_dir, "model_controlnet/ControlNet"))
+    controlnet = ControlNetModel.from_pretrained(os.path.join(model_dir, "model_controlnet/control_v11p_sd15_openpose"), torch_dtype=dtype)
+    pipe = StableDiffusionControlNetPipeline.from_pretrained(base_model_path, controlnet=controlnet, torch_dtype=dtype)
+    lora_style_path = style_model_path
+    lora_human_path = lora_model_path
+    pipe = merge_lora(pipe, lora_style_path, multiplier_style, from_safetensor=True)
+    pipe = merge_lora(pipe, lora_human_path, multiplier_human, from_safetensor=False)
+    pipe = pipe.to("cuda")
+    image_faces = []
+
+    for i in range(1):
+        inpaint_im = inpaint_images[i]
+        inpaint_im = crop_bottom(inpaint_im, output_img_size)
+
+        openpose_image = openpose(np.array(inpaint_im, np.uint8), include_hand=True, include_face=False)
+        w, h = inpaint_im.size
+        image_face = pipe(prompt=trigger_style + add_prompt_style + pos_prompt, image=openpose_image, height=h, width=w,
+                          guidance_scale=7, negative_prompt=neg_prompt, 
+                          num_inference_steps=40, num_images_per_prompt=1).images[0]
+        image_faces.append(image_face)
+        
+    selected_face = select_high_quality_face(input_img_dir)
+    swap_results = face_swap_fn(True, image_faces, selected_face)
+
+    controlnet = [
+        ControlNetModel.from_pretrained(os.path.join(model_dir, "model_controlnet/control_v11p_sd15_openpose"), torch_dtype=dtype),
+        ControlNetModel.from_pretrained(os.path.join(model_dir1, "contronet-canny"), torch_dtype=dtype)
+    ]
+    pipe = StableDiffusionControlNetInpaintPipeline.from_pretrained(base_model_path, controlnet=controlnet,
+                                                                    torch_dtype=dtype)
+    pipe.scheduler = UniPCMultistepScheduler.from_config(pipe.scheduler.config)
+    pipe = merge_lora(pipe, style_model_path, multiplier_style, from_safetensor=True)
+    pipe = merge_lora(pipe, lora_model_path, multiplier_human, from_safetensor=False)
+    pipe = pipe.to("cuda")
+
+    images_human = []  
+    images_auto = []
+    for i in range(1):
+        inpaint_im = inpaint_images[i]
+        inpaint_bbox, inpaint_keypoints = call_face_crop(det_pipeline, inpaint_im, 1.1)
+        eye_height = int((inpaint_keypoints[0, 1] + inpaint_keypoints[1, 1]) / 2)
+        canny_image = cv2.Canny(np.array(inpaint_im, np.uint8), 100, 200)[:, :, None]
+        mask = segment(segmentation_pipeline, inpaint_im, ksize=0.05, eyeh=eye_height)
+        canny_image = (canny_image * (1.0 - mask[:, :, None])).astype(np.uint8)
+        canny_image = Image.fromarray(np.concatenate([canny_image, canny_image, canny_image], axis=2))
+        
+        image_face = swap_results[i]
+        image_face = Image.fromarray(image_face[:, :, ::-1])
+
+        face_bbox, face_keypoints = call_face_crop(det_pipeline, image_face, 1.5)
+        face_mask = segment(segmentation_pipeline, image_face)
+        face_mask = np.expand_dims((face_mask * 255).astype(np.uint8), axis=2)
+        face_mask = np.concatenate([face_mask, face_mask, face_mask], axis=2)
+        face_mask = Image.fromarray(face_mask)
+        replaced_input_image, warp_mask = crop_and_paste(image_face, face_mask, inpaint_im, face_keypoints,
+                                                         inpaint_keypoints, face_bbox)
+        warp_mask = 1.0 - warp_mask
+        # cv2.imwrite('tmp_{}.png'.format(i), replaced_input_image[:, :, ::-1])
+
+        openpose_image = openpose(np.array(replaced_input_image * warp_mask, np.uint8), include_hand=True,
+                                  include_body=False, include_face=True)
+        # openpose_image.save('openpose_{}.png'.format(i))
+        read_control = [openpose_image, canny_image]
+        inpaint_mask, human_mask = segment(segmentation_pipeline, inpaint_im, ksize=0.1, ksize1=0.06, eyeh=eye_height, include_neck=False,
+                               warp_mask=warp_mask, return_human=True)
+        inpaint_with_mask = ((1.0 - inpaint_mask[:,:,None]) * np.array(inpaint_im))[:,:,::-1]
+        # cv2.imwrite('inpaint_with_mask_{}.png'.format(i), inpaint_with_mask)
+        print('Finishing segmenting images.')
+        images_human.extend(img2img_multicontrol(inpaint_im, read_control, [1.0, 0.2], pipe, inpaint_mask,
+                                                 trigger_style + add_prompt_style + pos_prompt, neg_prompt,
+                                                 strength=strength))
+        images_auto.extend(img2img_multicontrol(inpaint_im, read_control, [1.0, 0.2], pipe, np.zeros_like(inpaint_mask),
+                                                 trigger_style + add_prompt_style + pos_prompt, neg_prompt,
+                                                 strength=0.025))
+    
+        edge_add = np.array(inpaint_im).astype(np.int16) - np.array(images_auto[i]).astype(np.int16)
+        edge_add = edge_add * (1 - human_mask[:,:,None])
+        images_human[i] = Image.fromarray((np.clip(np.array(images_human[i]).astype(np.int16) + edge_add.astype(np.int16), 0, 255)).astype(np.uint8))
+        
+    
+    images_rst = []
+    for i in range(len(images_human)):
+        im = images_human[i]
+        canny_image = cv2.Canny(np.array(im, np.uint8), 100, 200)[:, :, None]
+        canny_image = Image.fromarray(np.concatenate([canny_image, canny_image, canny_image], axis=2))
+        openpose_image = openpose(np.array(im, np.uint8), include_hand=True, include_face=True)
+        read_control = [openpose_image, canny_image]
+        inpaint_mask, human_mask = segment(segmentation_pipeline, images_human[i], ksize=0.02, return_human=True)
+        print('Finishing segmenting images.')
+        image_rst = img2img_multicontrol(im, read_control, [0.8, 0.8], pipe, np.zeros_like(inpaint_mask),
+                                         trigger_style + add_prompt_style + pos_prompt, neg_prompt, strength=0.1,
+                                         num=1)[0]
+        image_auto = img2img_multicontrol(im, read_control, [0.8, 0.8], pipe, np.zeros_like(inpaint_mask),
+                                         trigger_style + add_prompt_style + pos_prompt, neg_prompt, strength=0.025,
+                                         num=1)[0]
+        edge_add = np.array(im).astype(np.int16) - np.array(image_auto).astype(np.int16)
+        edge_add = edge_add * (1 - human_mask[:,:,None])
+        image_rst = Image.fromarray((np.clip(np.array(image_rst).astype(np.int16) + edge_add.astype(np.int16), 0, 255)).astype(np.uint8))
+        
+        images_rst.append(image_rst)
+
+    for i in range(1):
+        images_rst[i].save('inference_{}.png'.format(i))
+
+    return images_rst
+
+def stylization_fn(use_stylization, rank_results):
+    if use_stylization:
+        ## TODO
+        pass
+    else:
+        return rank_results
+
+
+def main_model_inference(inpaint_image, strength, output_img_size,
+                         pos_prompt, neg_prompt, style_model_path, multiplier_style, multiplier_human, use_main_model,
+                         input_img_dir=None, base_model_path=None, lora_model_path=None):
+
+    if use_main_model:
+        multiplier_style_kwargs = {'multiplier_style': multiplier_style} if multiplier_style is not None else {}
+        multiplier_human_kwargs = {'multiplier_human': multiplier_human} if multiplier_human is not None else {}
+        return main_diffusion_inference_inpaint(inpaint_image, strength, output_img_size, pos_prompt, neg_prompt,
+                                                input_img_dir, base_model_path, style_model_path, lora_model_path,
+                                                **multiplier_style_kwargs, **multiplier_human_kwargs)
+
+def main_model_inference_multi(inpaint_image, strength, output_img_size,
+                         pos_prompt, neg_prompt, style_model_path, multiplier_style, multiplier_human, use_main_model,
+                         input_img_dir=None, base_model_path=None, lora_model_path=None):
+
+    if use_main_model:
+        multiplier_style_kwargs = {'multiplier_style': multiplier_style} if multiplier_style is not None else {}
+        multiplier_human_kwargs = {'multiplier_human': multiplier_human} if multiplier_human is not None else {}
+        return main_diffusion_inference_inpaint_multi(inpaint_image, strength, output_img_size, pos_prompt, neg_prompt,
+                                                input_img_dir, base_model_path, style_model_path, lora_model_path,
+                                                **multiplier_style_kwargs, **multiplier_human_kwargs)
+
+
+def select_high_quality_face(input_img_dir):
+    input_img_dir = str(input_img_dir) + '_labeled'
+    quality_score_list = []
+    abs_img_path_list = []
+    ## TODO
+    face_quality_func = pipeline(Tasks.face_quality_assessment, 'damo/cv_manual_face-quality-assessment_fqa',
+                                 model_revision='v2.0')
+
+    for img_name in os.listdir(input_img_dir):
+        if img_name.endswith('jsonl') or img_name.startswith('.ipynb') or img_name.startswith('.safetensors'):
+            continue
+
+        if img_name.endswith('jpg') or img_name.endswith('png'):
+            abs_img_name = os.path.join(input_img_dir, img_name)
+            face_quality_score = face_quality_func(abs_img_name)[OutputKeys.SCORES]
+            if face_quality_score is None:
+                quality_score_list.append(0)
+            else:
+                quality_score_list.append(face_quality_score[0])
+            abs_img_path_list.append(abs_img_name)
+
+    sort_idx = np.argsort(quality_score_list)[::-1]
+    print('Selected face: ' + abs_img_path_list[sort_idx[0]])
+
+    return Image.open(abs_img_path_list[sort_idx[0]])
+
+
+def face_swap_fn(use_face_swap, gen_results, template_face):
+    if use_face_swap:
+        ## TODO
+        out_img_list = []
+        image_face_fusion = pipeline('face_fusion_torch',
+                                     model='damo/cv_unet_face_fusion_torch', model_revision='v1.0.5')
+        segmentation_pipeline = pipeline(Tasks.image_segmentation, 'damo/cv_resnet101_image-multiple-human-parsing')
+        for img in gen_results:
+            result = image_face_fusion(dict(template=img, user=template_face))[OutputKeys.OUTPUT_IMG]
+            face_mask = segment(segmentation_pipeline, img, ksize=0.1)
+            result = (result * face_mask[:,:,None] + np.array(img)[:,:,::-1] * (1 - face_mask[:,:,None])).astype(np.uint8)
+            out_img_list.append(result)
+        return out_img_list
+    else:
+        ret_results = []
+        for img in gen_results:
+            ret_results.append(cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR))
+        return ret_results
+
+
+def post_process_fn(use_post_process, swap_results_ori, selected_face, num_gen_images):
+    if use_post_process:
+        sim_list = []
+        ## TODO
+        face_recognition_func = pipeline(Tasks.face_recognition, 'damo/cv_ir_face-recognition-ood_rts',
+                                         model_revision='v2.5')
+        face_det_func = pipeline(task=Tasks.face_detection, model='damo/cv_ddsar_face-detection_iclr23-damofd',
+                                 model_revision='v1.1')
+        swap_results = swap_results_ori
+
+        select_face_emb = face_recognition_func(selected_face)[OutputKeys.IMG_EMBEDDING][0]
+
+        for img in swap_results:
+            emb = face_recognition_func(img)[OutputKeys.IMG_EMBEDDING]
+            if emb is None or select_face_emb is None:
+                sim_list.append(0)
+            else:
+                sim = np.dot(emb, select_face_emb)
+                sim_list.append(sim.item())
+        sort_idx = np.argsort(sim_list)[::-1]
+
+        return np.array(swap_results)[sort_idx[:min(int(num_gen_images), len(swap_results))]]
+    else:
+        return np.array(swap_results_ori)
+
+
+class GenPortrait_inpaint:
+    def __init__(self, inpaint_img, strength, num_faces,
+                 pos_prompt, neg_prompt, style_model_path, multiplier_style, multiplier_human,
+                 use_main_model=True, use_face_swap=True,
+                 use_post_process=True, use_stylization=True):
+        self.use_main_model = use_main_model
+        self.use_face_swap = use_face_swap
+        self.use_post_process = use_post_process
+        self.use_stylization = use_stylization
+        self.multiplier_style = multiplier_style
+        self.multiplier_human = multiplier_human
+        self.style_model_path = style_model_path
+        self.pos_prompt = pos_prompt
+        self.neg_prompt = neg_prompt
+        self.inpaint_img = inpaint_img
+        self.strength = strength
+        self.num_faces = num_faces
+
+    def __call__(self, input_img_dir1=None, input_img_dir2=None, base_model_path=None,
+                 lora_model_path1=None, lora_model_path2=None, sub_path=None, revision=None):
+        base_model_path = snapshot_download(base_model_path, revision=revision)
+        if sub_path is not None and len(sub_path) > 0:
+            base_model_path = os.path.join(base_model_path, sub_path)
+
+        face_detection = pipeline(task=Tasks.face_detection, model='damo/cv_ddsar_face-detection_iclr23-damofd',
+                                  model_revision='v1.1')
+        result_det = face_detection(self.inpaint_img)
+        bboxes = result_det['boxes']
+        assert(len(bboxes)) == self.num_faces
+        bboxes = np.array(bboxes).astype(np.int16)
+        lefts = []
+        for bbox in bboxes:
+            lefts.append(bbox[0])
+        idxs = np.argsort(lefts)
+        
+        if lora_model_path1 != None:
+            face_box = bboxes[idxs[0]]
+            inpaint_img_large = cv2.imread(self.inpaint_img)
+            mask_large = np.ones_like(inpaint_img_large)
+            mask_large1 = np.zeros_like(inpaint_img_large)
+            h,w,_ = inpaint_img_large.shape
+            for i in range(len(bboxes)):
+                if i != idxs[0]:
+                    bbox = bboxes[i]
+                    inpaint_img_large[bbox[1]:bbox[3], bbox[0]:bbox[2]] = 0
+                    mask_large[bbox[1]:bbox[3], bbox[0]:bbox[2]] = 0
+
+            face_ratio = 0.45
+            cropl = int(max(face_box[3] - face_box[1], face_box[2] - face_box[0]) / face_ratio / 2)
+            cx = int((face_box[2] + face_box[0])/2)
+            cy = int((face_box[1] + face_box[3])/2)
+            cropup = min(cy, cropl)
+            cropbo = min(h-cy, cropl)
+            crople = min(cx, cropl)
+            cropri = min(w-cx, cropl)
+            inpaint_img = np.pad(inpaint_img_large[cy-cropup:cy+cropbo, cx-crople:cx+cropri], ((cropl-cropup, cropl-cropbo), (cropl-crople, cropl-cropri), (0, 0)), 'constant')
+            inpaint_img = cv2.resize(inpaint_img, (512, 512)) 
+            inpaint_img = Image.fromarray(inpaint_img[:,:,::-1])
+            mask_large1[cy-cropup:cy+cropbo, cx-crople:cx+cropri] = 1
+            mask_large = mask_large * mask_large1
+
+            gen_results = main_model_inference(inpaint_img, self.strength, 512,
+                                               self.pos_prompt, self.neg_prompt,
+                                               self.style_model_path, self.multiplier_style, self.multiplier_human,
+                                               self.use_main_model, input_img_dir=input_img_dir1,
+                                               lora_model_path=lora_model_path1, base_model_path=base_model_path)
+
+            # select_high_quality_face PIL
+            selected_face = select_high_quality_face(input_img_dir1)
+            # face_swap cv2
+            swap_results = face_swap_fn(self.use_face_swap, gen_results, selected_face)
+            # stylization
+            final_gen_results = swap_results
+
+            print(len(final_gen_results))
+
+            final_gen_results_new = []
+            inpaint_img_large = cv2.imread(self.inpaint_img)
+            ksize = int(10 * cropl / 256)
+            for i in range(len(final_gen_results)):
+                print('Start cropping.')
+                rst_gen = cv2.resize(final_gen_results[i], (cropl * 2, cropl * 2))
+                rst_crop = rst_gen[cropl-cropup:cropl+cropbo, cropl-crople:cropl+cropri]
+                print(rst_crop.shape)
+                inpaint_img_rst = np.zeros_like(inpaint_img_large)
+                print('Start pasting.')
+                inpaint_img_rst[cy-cropup:cy+cropbo, cx-crople:cx+cropri] = rst_crop
+                print('Fininsh pasting.')
+                print(inpaint_img_rst.shape, mask_large.shape, inpaint_img_large.shape)
+                mask_large = mask_large.astype(np.float32)
+                kernel = np.ones((ksize * 2, ksize * 2))
+                mask_large1 = cv2.erode(mask_large, kernel, iterations=1)
+                mask_large1 = cv2.GaussianBlur(mask_large1, (int(ksize * 1.8) * 2 + 1, int(ksize * 1.8) * 2 + 1), 0)
+                mask_large1[face_box[1]:face_box[3], face_box[0]:face_box[2]] = 1
+                mask_large = mask_large * mask_large1
+                final_inpaint_rst = (inpaint_img_rst.astype(np.float32) * mask_large.astype(np.float32) + inpaint_img_large.astype(np.float32) * (1.0 - mask_large.astype(np.float32))).astype(np.uint8)
+                print('Finish masking.')
+                final_gen_results_new.append(final_inpaint_rst)
+                print('Finish generating.')
+        else:
+            inpaint_img_large = cv2.imread(self.inpaint_img)
+            inpaint_img_le = cv2.imread(self.inpaint_img)
+            final_gen_results_new = [inpaint_img_le, inpaint_img_le, inpaint_img_le]
+        
+        for i in range(1):
+            cv2.imwrite('tmp_inpaint_left_{}.png'.format(i), final_gen_results_new[i])
+        
+        if lora_model_path2 != None and self.num_faces == 2:
+            face_box = bboxes[idxs[1]]
+            mask_large = np.ones_like(inpaint_img_large)
+            mask_large1 = np.zeros_like(inpaint_img_large)
+            h,w,_ = inpaint_img_large.shape
+            for i in range(len(bboxes)):
+                if i != idxs[1]:
+                    bbox = bboxes[i]
+                    inpaint_img_large[bbox[1]:bbox[3], bbox[0]:bbox[2]] = 0
+                    mask_large[bbox[1]:bbox[3], bbox[0]:bbox[2]] = 0
+
+            face_ratio = 0.45
+            cropl = int(max(face_box[3] - face_box[1], face_box[2] - face_box[0]) / face_ratio / 2)
+            cx = int((face_box[2] + face_box[0])/2)
+            cy = int((face_box[1] + face_box[3])/2)
+            cropup = min(cy, cropl)
+            cropbo = min(h-cy, cropl)
+            crople = min(cx, cropl)
+            cropri = min(w-cx, cropl)
+            mask_large1[cy-cropup:cy+cropbo, cx-crople:cx+cropri] = 1
+            mask_large = mask_large * mask_large1
+            
+            inpaint_imgs = []
+            for i in range(1):
+                inpaint_img_large = final_gen_results_new[i] * mask_large
+                inpaint_img = np.pad(inpaint_img_large[cy-cropup:cy+cropbo, cx-crople:cx+cropri], ((cropl-cropup, cropl-cropbo), (cropl-crople, cropl-cropri), (0, 0)), 'constant')
+                inpaint_img = cv2.resize(inpaint_img, (512, 512)) 
+                inpaint_img = Image.fromarray(inpaint_img[:,:,::-1])
+                inpaint_imgs.append(inpaint_img)
+            
+
+            gen_results = main_model_inference_multi(inpaint_imgs, self.strength, 512,
+                                               self.pos_prompt, self.neg_prompt,
+                                               self.style_model_path, self.multiplier_style, self.multiplier_human,
+                                               self.use_main_model, input_img_dir=input_img_dir2,
+                                               lora_model_path=lora_model_path2, base_model_path=base_model_path)
+
+            # select_high_quality_face PIL
+            selected_face = select_high_quality_face(input_img_dir2)
+            # face_swap cv2
+            swap_results = face_swap_fn(self.use_face_swap, gen_results, selected_face)
+            # stylization
+            final_gen_results = swap_results
+
+            print(len(final_gen_results))
+
+            final_gen_results_final = []
+            inpaint_img_large = cv2.imread(self.inpaint_img)
+            ksize = int(10 * cropl / 256)
+            for i in range(len(final_gen_results)):
+                print('Start cropping.')
+                rst_gen = cv2.resize(final_gen_results[i], (cropl * 2, cropl * 2))
+                rst_crop = rst_gen[cropl-cropup:cropl+cropbo, cropl-crople:cropl+cropri]
+                print(rst_crop.shape)
+                inpaint_img_rst = np.zeros_like(inpaint_img_large)
+                print('Start pasting.')
+                inpaint_img_rst[cy-cropup:cy+cropbo, cx-crople:cx+cropri] = rst_crop
+                print('Fininsh pasting.')
+                print(inpaint_img_rst.shape, mask_large.shape, inpaint_img_large.shape)
+                mask_large = mask_large.astype(np.float32)
+                kernel = np.ones((ksize * 2, ksize * 2))
+                mask_large1 = cv2.erode(mask_large, kernel, iterations=1)
+                mask_large1 = cv2.GaussianBlur(mask_large1, (int(ksize * 1.8) * 2 + 1, int(ksize * 1.8) * 2 + 1), 0)
+                mask_large1[face_box[1]:face_box[3], face_box[0]:face_box[2]] = 1
+                mask_large = mask_large * mask_large1
+                final_inpaint_rst = (inpaint_img_rst.astype(np.float32) * mask_large.astype(np.float32) + final_gen_results_new[i].astype(np.float32) * (1.0 - mask_large.astype(np.float32))).astype(np.uint8)
+                print('Finish masking.')
+                final_gen_results_final.append(final_inpaint_rst)
+                print('Finish generating.')
+        else:
+            final_gen_results_final = final_gen_results_new
+
+        outputs = final_gen_results_final
+        outputs_RGB = []
+        for out_tmp in outputs:
+            outputs_RGB.append(cv2.cvtColor(out_tmp, cv2.COLOR_BGR2RGB))
+        image_path = './lora_result.png'
+        if len(outputs) > 0:
+            result = concatenate_images(outputs)
+            cv2.imwrite(image_path, result)
+
+        return final_gen_results_final
+
+def compress_image(input_path, target_size):
+    output_path = change_extension_to_jpg(input_path)
+
+    image = cv2.imread(input_path)
+    
+    quality = 95
+    try:
+        while cv2.imencode('.jpg', image, [cv2.IMWRITE_JPEG_QUALITY, quality])[1].size > target_size:
+            quality -= 5
+    except:
+        import pdb;pdb.set_trace()
+
+    compressed_image = cv2.imencode('.jpg', image, [cv2.IMWRITE_JPEG_QUALITY, quality])[1].tostring()
+
+    with open(output_path, 'wb') as f:
+        f.write(compressed_image)
+    return output_path
+
+
+def change_extension_to_jpg(image_path):
+
+    base_name = os.path.basename(image_path)
+    new_base_name = os.path.splitext(base_name)[0] + ".jpg"
+
+    directory = os.path.dirname(image_path)
+
+    new_image_path = os.path.join(directory, new_base_name)
+    return new_image_path

facechain/facechain/merge_lora.py

@@ -0,0 +1,75 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+import torch
+import os
+import re
+from collections import defaultdict
+from safetensors.torch import load_file
+
+
+def merge_lora(pipeline, lora_path, multiplier, from_safetensor=False, device='cpu', dtype=torch.float32):
+    LORA_PREFIX_UNET = "lora_unet"
+    LORA_PREFIX_TEXT_ENCODER = "lora_te"
+    if from_safetensor:
+        state_dict = load_file(lora_path, device=device)
+    else:
+        if os.path.exists(os.path.join(lora_path, 'pytorch_lora_weights.bin')):
+            checkpoint = torch.load(os.path.join(lora_path, 'pytorch_lora_weights.bin'), map_location=torch.device(device))
+        elif os.path.exists(os.path.join(lora_path, 'pytorch_lora_weights.safetensors')):
+            checkpoint= load_file(os.path.join(lora_path,'pytorch_lora_weights.safetensors'), device=device)
+        new_dict = dict()
+        for idx, key in enumerate(checkpoint):
+            new_key = re.sub(r'\.processor\.', '_', key)
+            new_key = re.sub(r'mid_block\.', 'mid_block_', new_key)
+            new_key = re.sub('_lora.up.', '.lora_up.', new_key)
+            new_key = re.sub('_lora.down.', '.lora_down.', new_key)
+            new_key = re.sub(r'\.(\d+)\.', '_\\1_', new_key)
+            new_key = re.sub('to_out', 'to_out_0', new_key)
+            new_key = 'lora_unet_' + new_key
+            new_dict[new_key] = checkpoint[key]
+            state_dict = new_dict
+    updates = defaultdict(dict)
+    for key, value in state_dict.items():
+        layer, elem = key.split('.', 1)
+        updates[layer][elem] = value
+
+    for layer, elems in updates.items():
+
+        if "text" in layer:
+            layer_infos = layer.split(LORA_PREFIX_TEXT_ENCODER + "_")[-1].split("_")
+            curr_layer = pipeline.text_encoder
+        else:
+            layer_infos = layer.split(LORA_PREFIX_UNET + "_")[-1].split("_")
+            curr_layer = pipeline.unet
+
+        temp_name = layer_infos.pop(0)
+        while len(layer_infos) > -1:
+            try:
+                curr_layer = curr_layer.__getattr__(temp_name)
+                if len(layer_infos) > 0:
+                    temp_name = layer_infos.pop(0)
+                elif len(layer_infos) == 0:
+                    break
+            except Exception:
+                if len(layer_infos) == 0:
+                    print('Error loading layer')
+                if len(temp_name) > 0:
+                    temp_name += "_" + layer_infos.pop(0)
+                else:
+                    temp_name = layer_infos.pop(0)
+
+        weight_up = elems['lora_up.weight'].to(dtype)
+        weight_down = elems['lora_down.weight'].to(dtype)
+        if 'alpha' in elems.keys():
+            alpha = elems['alpha'].item() / weight_up.shape[1]
+        else:
+            alpha = 1.0
+
+        curr_layer.weight.data = curr_layer.weight.data.to(device)
+        if len(weight_up.shape) == 4:
+            curr_layer.weight.data += multiplier * alpha * torch.mm(weight_up.squeeze(3).squeeze(2),
+                                                                    weight_down.squeeze(3).squeeze(2)).unsqueeze(
+                2).unsqueeze(3)
+        else:
+            curr_layer.weight.data += multiplier * alpha * torch.mm(weight_up, weight_down)
+
+    return pipeline

facechain/facechain/train_text_to_image_lora.py

@@ -0,0 +1,1161 @@
+# coding=utf-8
+# Copyright (c) Alibaba, Inc. and its affiliates.
+# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Fine-tuning script for Stable Diffusion for text2image with support for LoRA."""
+
+import argparse
+import base64
+import itertools
+import json
+import logging
+import math
+import os
+import random
+import shutil
+from glob import glob
+from pathlib import Path
+
+import cv2
+import datasets
+import diffusers
+import numpy as np
+import onnxruntime
+import PIL.Image
+import torch
+import torch.nn.functional as F
+import torch.utils.checkpoint
+from torch import Tensor
+from typing import List, Optional, Tuple, Union
+import torchvision.transforms.functional as Ft
+import transformers
+from accelerate import Accelerator
+from accelerate.logging import get_logger
+from accelerate.utils import ProjectConfiguration, set_seed
+from datasets import load_dataset
+from diffusers import (AutoencoderKL, DDPMScheduler, DiffusionPipeline,
+                       DPMSolverMultistepScheduler,
+                       StableDiffusionInpaintPipeline, UNet2DConditionModel)
+from diffusers.loaders import AttnProcsLayers
+from diffusers.models.attention_processor import LoRAAttnProcessor
+from diffusers.optimization import get_scheduler
+from diffusers.utils import check_min_version, is_wandb_available
+from diffusers.utils.import_utils import is_xformers_available
+from huggingface_hub import create_repo, upload_folder
+from facechain.utils import snapshot_download
+
+from packaging import version
+from PIL import Image
+from torchvision import transforms
+from tqdm.auto import tqdm
+from torch import multiprocessing
+from transformers import CLIPTextModel, CLIPTokenizer
+
+from facechain.inference import data_process_fn
+
+# Will error if the minimal version of diffusers is not installed. Remove at your own risks.
+check_min_version("0.14.0.dev0")
+
+logger = get_logger(__name__, log_level="INFO")
+
+
+class FaceCrop(torch.nn.Module):
+
+    @staticmethod
+    def get_params(img: Tensor) -> Tuple[int, int, int, int]:
+        _, h, w = Ft.get_dimensions(img)
+        if h != w:
+            raise ValueError(f"The input image is not square.")
+        ratio = torch.rand(size=(1,)).item() * 0.1 + 0.35
+        yc = torch.rand(size=(1,)).item() * 0.15 + 0.35
+
+        th = int(h / 1.15 * 0.35 / ratio)
+        tw = th
+
+        cx = int(0.5 * w)
+        cy = int(0.5 / 1.15 * h)
+
+        i = min(max(int(cy - yc * th), 0), h - th)
+        j = int(cx - 0.5 * tw)
+
+        return i, j, th, tw
+
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, img):
+        i, j, h, w = self.get_params(img)
+
+        return Ft.crop(img, i, j, h, w)
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}"
+
+
+def save_model_card(repo_id: str, images=None, base_model=str, dataset_name=str, repo_folder=None):
+    img_str = ""
+    for i, image in enumerate(images):
+        image.save(os.path.join(repo_folder, f"image_{i}.png"))
+        img_str += f"![img_{i}](./image_{i}.png)\n"
+
+    yaml = f"""
+---
+license: creativeml-openrail-m
+base_model: {base_model}
+tags:
+- stable-diffusion
+- stable-diffusion-diffusers
+- text-to-image
+- diffusers
+- lora
+inference: true
+---
+    """
+    model_card = f"""
+# LoRA text2image fine-tuning - {repo_id}
+These are LoRA adaption weights for {base_model}. The weights were fine-tuned on the {dataset_name} dataset. You can find some example images in the following. \n
+{img_str}
+"""
+    with open(os.path.join(repo_folder, "README.md"), "w") as f:
+        f.write(yaml + model_card)
+
+
+def softmax(x):
+    x -= np.max(x, axis=0, keepdims=True)
+    x = np.exp(x) / np.sum(np.exp(x), axis=0, keepdims=True)
+    return x
+
+
+def get_rot(image):
+    model_dir = snapshot_download('Cherrytest/rot_bgr',
+                                  revision='v1.0.0')
+    model_path = os.path.join(model_dir, 'rot_bgr.onnx')
+    ort_session = onnxruntime.InferenceSession(model_path)
+
+    img_cv = cv2.cvtColor(np.asarray(image), cv2.COLOR_RGB2BGR)
+    img_clone = img_cv.copy()
+    img_np = cv2.resize(img_cv, (224, 224))
+    img_np = img_np.astype(np.float32)
+    mean = np.array([103.53, 116.28, 123.675], dtype=np.float32).reshape((1, 1, 3))
+    norm = np.array([0.01742919, 0.017507, 0.01712475], dtype=np.float32).reshape((1, 1, 3))
+    img_np = (img_np - mean) * norm
+    img_tensor = torch.from_numpy(img_np)
+    img_tensor = img_tensor.unsqueeze(0)
+    img_nchw = img_tensor.permute(0, 3, 1, 2)
+    ort_inputs = {ort_session.get_inputs()[0].name: img_nchw.numpy()}
+    outputs = ort_session.run(None, ort_inputs)
+    logits = outputs[0].reshape((-1,))
+    probs = softmax(logits)
+    rot_idx = np.argmax(probs)
+    if rot_idx == 1:
+        print('rot 90')
+        img_clone = cv2.transpose(img_clone)
+        img_clone = np.flip(img_clone, 1)
+        return Image.fromarray(cv2.cvtColor(img_clone, cv2.COLOR_BGR2RGB))
+    elif rot_idx == 2:
+        print('rot 180')
+        img_clone = cv2.flip(img_clone, -1)
+        return Image.fromarray(cv2.cvtColor(img_clone, cv2.COLOR_BGR2RGB))
+    elif rot_idx == 3:
+        print('rot 270')
+        img_clone = cv2.transpose(img_clone)
+        img_clone = np.flip(img_clone, 0)
+        return Image.fromarray(cv2.cvtColor(img_clone, cv2.COLOR_BGR2RGB))
+    else:
+        return image
+
+
+def prepare_dataset(instance_images: list, output_dataset_dir):
+    if not os.path.exists(output_dataset_dir):
+        os.makedirs(output_dataset_dir)
+    for i, temp_path in enumerate(instance_images):
+        image = PIL.Image.open(temp_path)
+        # image = PIL.Image.open(temp_path.name)
+        '''
+        w, h = image.size
+        max_size = max(w, h)
+        ratio =  1024 / max_size
+        new_w = round(w * ratio)
+        new_h = round(h * ratio)
+        '''
+        image = image.convert('RGB')
+        image = get_rot(image)
+        # image = image.resize((new_w, new_h))
+        # image = image.resize((new_w, new_h), PIL.Image.ANTIALIAS)
+        out_path = f'{output_dataset_dir}/{i:03d}.jpg'
+        image.save(out_path, format='JPEG', quality=100)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Simple example of a training script.")
+    parser.add_argument(
+        "--pretrained_model_name_or_path",
+        type=str,
+        default=None,
+        required=True,
+        help="Path to pretrained model or model identifier.",
+    )
+    parser.add_argument(
+        "--revision",
+        type=str,
+        default=None,
+        required=False,
+        help="Revision of pretrained model identifier.",
+    )
+    parser.add_argument(
+        "--sub_path",
+        type=str,
+        default=None,
+        required=False,
+        help="The sub model path of the `pretrained_model_name_or_path`",
+    )
+    parser.add_argument(
+        "--dataset_name",
+        type=str,
+        default=None,
+        help=(
+            "The data images dir"
+        ),
+    )
+    parser.add_argument(
+        "--dataset_config_name",
+        type=str,
+        default=None,
+        help="The config of the Dataset, leave as None if there's only one config.",
+    )
+    parser.add_argument(
+        "--train_data_dir",
+        type=str,
+        default=None,
+        help=(
+            "A folder containing the training data. Folder contents must follow the structure described in"
+            " https://huggingface.co/docs/datasets/image_dataset#imagefolder. In particular, a `metadata.jsonl` file"
+            " must exist to provide the captions for the images. Ignored if `dataset_name` is specified."
+        ),
+    )
+    parser.add_argument(
+        "--output_dataset_name",
+        type=str,
+        default=None,
+        help=(
+            "The dataset dir after processing"
+        ),
+    )
+    parser.add_argument(
+        "--image_column", type=str, default="image", help="The column of the dataset containing an image."
+    )
+    parser.add_argument(
+        "--caption_column",
+        type=str,
+        default="text",
+        help="The column of the dataset containing a caption or a list of captions.",
+    )
+    parser.add_argument(
+        "--validation_prompt", type=str, default=None, help="A prompt that is sampled during training for inference."
+    )
+    parser.add_argument(
+        "--num_validation_images",
+        type=int,
+        default=1,
+        help="Number of images that should be generated during validation with `validation_prompt`.",
+    )
+    parser.add_argument(
+        "--validation_epochs",
+        type=int,
+        default=1,
+        help=(
+            "Run fine-tuning validation every X epochs. The validation process consists of running the prompt"
+            " `args.validation_prompt` multiple times: `args.num_validation_images`."
+        ),
+    )
+    parser.add_argument(
+        "--max_train_samples",
+        type=int,
+        default=None,
+        help=(
+            "For debugging purposes or quicker training, truncate the number of training examples to this "
+            "value if set."
+        ),
+    )
+    parser.add_argument(
+        "--output_dir",
+        type=str,
+        default="sd-model-finetuned-lora",
+        help="The output directory where the model predictions and checkpoints will be written.",
+    )
+    parser.add_argument(
+        "--cache_dir",
+        type=str,
+        default=None,
+        help="The directory where the downloaded models and datasets will be stored.",
+    )
+    parser.add_argument("--seed", type=int, default=None, help="A seed for reproducible training.")
+    parser.add_argument(
+        "--resolution",
+        type=int,
+        default=512,
+        help=(
+            "The resolution for input images, all the images in the train/validation dataset will be resized to this"
+            " resolution"
+        ),
+    )
+    parser.add_argument(
+        "--center_crop",
+        default=False,
+        action="store_true",
+        help=(
+            "Whether to center crop the input images to the resolution. If not set, the images will be randomly"
+            " cropped. The images will be resized to the resolution first before cropping."
+        ),
+    )
+    parser.add_argument(
+        "--random_flip",
+        action="store_true",
+        help="whether to randomly flip images horizontally",
+    )
+    parser.add_argument("--train_text_encoder", action="store_true", help="Whether to train the text encoder")
+
+    # lora args
+    parser.add_argument("--use_peft", action="store_true", help="Whether to use peft to support lora")
+    parser.add_argument("--lora_r", type=int, default=4, help="Lora rank, only used if use_lora is True")
+    parser.add_argument("--lora_alpha", type=int, default=32, help="Lora alpha, only used if lora is True")
+    parser.add_argument("--lora_dropout", type=float, default=0.0, help="Lora dropout, only used if use_lora is True")
+    parser.add_argument(
+        "--lora_bias",
+        type=str,
+        default="none",
+        help="Bias type for Lora. Can be 'none', 'all' or 'lora_only', only used if use_lora is True",
+    )
+    parser.add_argument(
+        "--lora_text_encoder_r",
+        type=int,
+        default=4,
+        help="Lora rank for text encoder, only used if `use_lora` and `train_text_encoder` are True",
+    )
+    parser.add_argument(
+        "--lora_text_encoder_alpha",
+        type=int,
+        default=32,
+        help="Lora alpha for text encoder, only used if `use_lora` and `train_text_encoder` are True",
+    )
+    parser.add_argument(
+        "--lora_text_encoder_dropout",
+        type=float,
+        default=0.0,
+        help="Lora dropout for text encoder, only used if `use_lora` and `train_text_encoder` are True",
+    )
+    parser.add_argument(
+        "--lora_text_encoder_bias",
+        type=str,
+        default="none",
+        help="Bias type for Lora. Can be 'none', 'all' or 'lora_only', only used if use_lora and `train_text_encoder` are True",
+    )
+
+    parser.add_argument(
+        "--train_batch_size", type=int, default=16, help="Batch size (per device) for the training dataloader."
+    )
+    parser.add_argument("--num_train_epochs", type=int, default=100)
+    parser.add_argument(
+        "--max_train_steps",
+        type=int,
+        default=None,
+        help="Total number of training steps to perform.  If provided, overrides num_train_epochs.",
+    )
+    parser.add_argument(
+        "--gradient_accumulation_steps",
+        type=int,
+        default=1,
+        help="Number of updates steps to accumulate before performing a backward/update pass.",
+    )
+    parser.add_argument(
+        "--gradient_checkpointing",
+        action="store_true",
+        help="Whether or not to use gradient checkpointing to save memory at the expense of slower backward pass.",
+    )
+    parser.add_argument(
+        "--learning_rate",
+        type=float,
+        default=1e-4,
+        help="Initial learning rate (after the potential warmup period) to use.",
+    )
+    parser.add_argument(
+        "--scale_lr",
+        action="store_true",
+        default=False,
+        help="Scale the learning rate by the number of GPUs, gradient accumulation steps, and batch size.",
+    )
+    parser.add_argument(
+        "--lr_scheduler",
+        type=str,
+        default="constant",
+        help=(
+            'The scheduler type to use. Choose between ["linear", "cosine", "cosine_with_restarts", "polynomial",'
+            ' "constant", "constant_with_warmup"]'
+        ),
+    )
+    parser.add_argument(
+        "--lr_warmup_steps", type=int, default=500, help="Number of steps for the warmup in the lr scheduler."
+    )
+    parser.add_argument(
+        "--use_8bit_adam", action="store_true", help="Whether or not to use 8-bit Adam from bitsandbytes."
+    )
+    parser.add_argument(
+        "--allow_tf32",
+        action="store_true",
+        help=(
+            "Whether or not to allow TF32 on Ampere GPUs. Can be used to speed up training. For more information, see"
+            " https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices"
+        ),
+    )
+    parser.add_argument(
+        "--dataloader_num_workers",
+        type=int,
+        default=0,
+        help=(
+            "Number of subprocesses to use for data loading. 0 means that the data will be loaded in the main process."
+        ),
+    )
+    parser.add_argument("--adam_beta1", type=float, default=0.9, help="The beta1 parameter for the Adam optimizer.")
+    parser.add_argument("--adam_beta2", type=float, default=0.999, help="The beta2 parameter for the Adam optimizer.")
+    parser.add_argument("--adam_weight_decay", type=float, default=1e-2, help="Weight decay to use.")
+    parser.add_argument("--adam_epsilon", type=float, default=1e-08, help="Epsilon value for the Adam optimizer")
+    parser.add_argument("--max_grad_norm", default=1.0, type=float, help="Max gradient norm.")
+    parser.add_argument("--push_to_hub", action="store_true", help="Whether or not to push the model to the Hub.")
+    parser.add_argument("--hub_token", type=str, default=None, help="The token to use to push to the Model Hub.")
+    parser.add_argument(
+        "--hub_model_id",
+        type=str,
+        default=None,
+        help="The name of the repository to keep in sync with the local `output_dir`.",
+    )
+    parser.add_argument(
+        "--logging_dir",
+        type=str,
+        default="logs",
+        help=(
+            "[TensorBoard](https://www.tensorflow.org/tensorboard) log directory. Will default to"
+            " *output_dir/runs/**CURRENT_DATETIME_HOSTNAME***."
+        ),
+    )
+    parser.add_argument(
+        "--mixed_precision",
+        type=str,
+        default=None,
+        choices=["no", "fp16", "bf16"],
+        help=(
+            "Whether to use mixed precision. Choose between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >="
+            " 1.10.and an Nvidia Ampere GPU.  Default to the value of accelerate config of the current system or the"
+            " flag passed with the `accelerate.launch` command. Use this argument to override the accelerate config."
+        ),
+    )
+    parser.add_argument(
+        "--report_to",
+        type=str,
+        default="tensorboard",
+        help=(
+            'The integration to report the results and logs to. Supported platforms are `"tensorboard"`'
+            ' (default), `"wandb"` and `"comet_ml"`. Use `"all"` to report to all integrations.'
+        ),
+    )
+    parser.add_argument("--local_rank", type=int, default=-1, help="For distributed training: local_rank")
+    parser.add_argument(
+        "--checkpointing_steps",
+        type=int,
+        default=500,
+        help=(
+            "Save a checkpoint of the training state every X updates. These checkpoints are only suitable for resuming"
+            " training using `--resume_from_checkpoint`."
+        ),
+    )
+    parser.add_argument(
+        "--checkpoints_total_limit",
+        type=int,
+        default=None,
+        help=(
+            "Max number of checkpoints to store. Passed as `total_limit` to the `Accelerator` `ProjectConfiguration`."
+            " See Accelerator::save_state https://huggingface.co/docs/accelerate/package_reference/accelerator#accelerate.Accelerator.save_state"
+            " for more docs"
+        ),
+    )
+    parser.add_argument(
+        "--resume_from_checkpoint",
+        type=str,
+        default=None,
+        help=(
+            "Whether training should be resumed from a previous checkpoint. Use a path saved by"
+            ' `--checkpointing_steps`, or `"latest"` to automatically select the last available checkpoint.'
+        ),
+    )
+    parser.add_argument(
+        "--enable_xformers_memory_efficient_attention", action="store_true", help="Whether or not to use xformers."
+    )
+
+    args = parser.parse_args()
+    env_local_rank = int(os.environ.get("LOCAL_RANK", -1))
+    if env_local_rank != -1 and env_local_rank != args.local_rank:
+        args.local_rank = env_local_rank
+
+    # Sanity checks
+    if args.dataset_name is None and args.train_data_dir is None and args.output_dataset_name is None:
+        raise ValueError("Need either a dataset name or a training folder.")
+
+    return args
+
+
+DATASET_NAME_MAPPING = {
+    "lambdalabs/pokemon-blip-captions": ("image", "text"),
+}
+
+
+def main():
+
+    args = parse_args()
+    logging_dir = os.path.join(args.output_dir, args.logging_dir)
+    shutil.rmtree(args.output_dir, ignore_errors=True)
+    os.makedirs(args.output_dir)
+
+    if args.dataset_name is not None:
+        # if dataset_name is None, then it's called from the gradio
+        # the data processing will be executed in the app.py to save the gpu memory.
+        print('All input images:', args.dataset_name)
+        args.dataset_name = [os.path.join(args.dataset_name, x) for x in os.listdir(args.dataset_name)]
+        shutil.rmtree(args.output_dataset_name, ignore_errors=True)
+        prepare_dataset(args.dataset_name, args.output_dataset_name)
+        ## Our data process fn
+        data_process_fn(input_img_dir=args.output_dataset_name, use_data_process=True)
+
+    args.dataset_name = args.output_dataset_name + '_labeled'
+
+    accelerator_project_config = ProjectConfiguration(
+        total_limit=args.checkpoints_total_limit, project_dir=args.output_dir, logging_dir=logging_dir
+    )
+
+    accelerator = Accelerator(
+        gradient_accumulation_steps=args.gradient_accumulation_steps,
+        mixed_precision=args.mixed_precision,
+        log_with=args.report_to,
+        project_config=accelerator_project_config,
+    )
+    if args.report_to == "wandb":
+        if not is_wandb_available():
+            raise ImportError("Make sure to install wandb if you want to use it for logging during training.")
+        import wandb
+
+    # Make one log on every process with the configuration for debugging.
+    logging.basicConfig(
+        format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
+        datefmt="%m/%d/%Y %H:%M:%S",
+        level=logging.INFO,
+    )
+    logger.info(accelerator.state, main_process_only=False)
+    if accelerator.is_local_main_process:
+        datasets.utils.logging.set_verbosity_warning()
+        transformers.utils.logging.set_verbosity_warning()
+        diffusers.utils.logging.set_verbosity_info()
+    else:
+        datasets.utils.logging.set_verbosity_error()
+        transformers.utils.logging.set_verbosity_error()
+        diffusers.utils.logging.set_verbosity_error()
+
+    # If passed along, set the training seed now.
+    if args.seed is not None:
+        set_seed(args.seed)
+
+    # Handle the repository creation
+    if accelerator.is_main_process:
+        if args.output_dir is not None:
+            os.makedirs(args.output_dir, exist_ok=True)
+
+        if args.push_to_hub:
+            repo_id = create_repo(
+                repo_id=args.hub_model_id or Path(args.output_dir).name, exist_ok=True, token=args.hub_token
+            ).repo_id
+
+    ## Download foundation Model
+    model_dir = snapshot_download(args.pretrained_model_name_or_path,
+                                  revision=args.revision,
+                                  user_agent={'invoked_by': 'trainer', 'third_party': 'facechain'})
+
+    if args.sub_path is not None and len(args.sub_path) > 0:
+        model_dir = os.path.join(model_dir, args.sub_path)
+
+    # Load scheduler, tokenizer and models.
+    noise_scheduler = DDPMScheduler.from_pretrained(model_dir, subfolder="scheduler")
+    tokenizer = CLIPTokenizer.from_pretrained(
+        model_dir, subfolder="tokenizer"
+    )
+    text_encoder = CLIPTextModel.from_pretrained(
+        model_dir, subfolder="text_encoder"
+    )
+    vae = AutoencoderKL.from_pretrained(model_dir, subfolder="vae")
+    unet = UNet2DConditionModel.from_pretrained(
+        model_dir, subfolder="unet"
+    )
+
+    # For mixed precision training we cast the text_encoder and vae weights to half-precision
+    # as these models are only used for inference, keeping weights in full precision is not required.
+    weight_dtype = torch.float32
+    if accelerator.mixed_precision == "fp16":
+        weight_dtype = torch.float16
+    elif accelerator.mixed_precision == "bf16":
+        weight_dtype = torch.bfloat16
+
+    if args.use_peft:
+        from peft import LoraConfig, LoraModel, get_peft_model_state_dict, set_peft_model_state_dict
+
+        UNET_TARGET_MODULES = ["to_q", "to_v", "query", "value"]
+        TEXT_ENCODER_TARGET_MODULES = ["q_proj", "v_proj"]
+
+        config = LoraConfig(
+            r=args.lora_r,
+            lora_alpha=args.lora_alpha,
+            target_modules=UNET_TARGET_MODULES,
+            lora_dropout=args.lora_dropout,
+            bias=args.lora_bias,
+        )
+        unet = LoraModel(config, unet)
+
+        vae.requires_grad_(False)
+        if args.train_text_encoder:
+            config = LoraConfig(
+                r=args.lora_text_encoder_r,
+                lora_alpha=args.lora_text_encoder_alpha,
+                target_modules=TEXT_ENCODER_TARGET_MODULES,
+                lora_dropout=args.lora_text_encoder_dropout,
+                bias=args.lora_text_encoder_bias,
+            )
+            text_encoder = LoraModel(config, text_encoder)
+    else:
+        # freeze parameters of models to save more memory
+        unet.requires_grad_(False)
+        vae.requires_grad_(False)
+
+        text_encoder.requires_grad_(False)
+
+        # now we will add new LoRA weights to the attention layers
+        # It's important to realize here how many attention weights will be added and of which sizes
+        # The sizes of the attention layers consist only of two different variables:
+        # 1) - the "hidden_size", which is increased according to `unet.config.block_out_channels`.
+        # 2) - the "cross attention size", which is set to `unet.config.cross_attention_dim`.
+
+        # Let's first see how many attention processors we will have to set.
+        # For Stable Diffusion, it should be equal to:
+        # - down blocks (2x attention layers) * (2x transformer layers) * (3x down blocks) = 12
+        # - mid blocks (2x attention layers) * (1x transformer layers) * (1x mid blocks) = 2
+        # - up blocks (2x attention layers) * (3x transformer layers) * (3x down blocks) = 18
+        # => 32 layers
+
+        # Set correct lora layers
+        lora_attn_procs = {}
+        for name in unet.attn_processors.keys():
+            cross_attention_dim = None if name.endswith("attn1.processor") else unet.config.cross_attention_dim
+            if name.startswith("mid_block"):
+                hidden_size = unet.config.block_out_channels[-1]
+            elif name.startswith("up_blocks"):
+                block_id = int(name[len("up_blocks.")])
+                hidden_size = list(reversed(unet.config.block_out_channels))[block_id]
+            elif name.startswith("down_blocks"):
+                block_id = int(name[len("down_blocks.")])
+                hidden_size = unet.config.block_out_channels[block_id]
+
+            lora_attn_procs[name] = LoRAAttnProcessor(hidden_size=hidden_size, cross_attention_dim=cross_attention_dim, rank=args.lora_r)
+
+        unet.set_attn_processor(lora_attn_procs)
+        lora_layers = AttnProcsLayers(unet.attn_processors)
+
+    # Move unet, vae and text_encoder to device and cast to weight_dtype
+    vae.to(accelerator.device, dtype=weight_dtype)
+    if not args.train_text_encoder:
+        text_encoder.to(accelerator.device, dtype=weight_dtype)
+
+    if args.enable_xformers_memory_efficient_attention:
+        if is_xformers_available():
+            import xformers
+
+            xformers_version = version.parse(xformers.__version__)
+            if xformers_version == version.parse("0.0.16"):
+                logger.warn(
+                    "xFormers 0.0.16 cannot be used for training in some GPUs. If you observe problems during training, please update xFormers to at least 0.0.17. See https://huggingface.co/docs/diffusers/main/en/optimization/xformers for more details."
+                )
+            unet.enable_xformers_memory_efficient_attention()
+        else:
+            raise ValueError("xformers is not available. Make sure it is installed correctly")
+
+    # Enable TF32 for faster training on Ampere GPUs,
+    # cf https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices
+    if args.allow_tf32:
+        torch.backends.cuda.matmul.allow_tf32 = True
+
+    if args.scale_lr:
+        args.learning_rate = (
+            args.learning_rate * args.gradient_accumulation_steps * args.train_batch_size * accelerator.num_processes
+        )
+
+    # Initialize the optimizer
+    if args.use_8bit_adam:
+        try:
+            import bitsandbytes as bnb
+        except ImportError:
+            raise ImportError(
+                "Please install bitsandbytes to use 8-bit Adam. You can do so by running `pip install bitsandbytes`"
+            )
+
+        optimizer_cls = bnb.optim.AdamW8bit
+    else:
+        optimizer_cls = torch.optim.AdamW
+
+    if args.use_peft:
+        # Optimizer creation
+        params_to_optimize = (
+            itertools.chain(unet.parameters(), text_encoder.parameters())
+            if args.train_text_encoder
+            else unet.parameters()
+        )
+        optimizer = optimizer_cls(
+            params_to_optimize,
+            lr=args.learning_rate,
+            betas=(args.adam_beta1, args.adam_beta2),
+            weight_decay=args.adam_weight_decay,
+            eps=args.adam_epsilon,
+        )
+    else:
+        optimizer = optimizer_cls(
+            lora_layers.parameters(),
+            lr=args.learning_rate,
+            betas=(args.adam_beta1, args.adam_beta2),
+            weight_decay=args.adam_weight_decay,
+            eps=args.adam_epsilon,
+        )
+
+    # Get the datasets: you can either provide your own training and evaluation files (see below)
+    # or specify a Dataset from the hub (the dataset will be downloaded automatically from the datasets Hub).
+
+    # In distributed training, the load_dataset function guarantees that only one local process can concurrently
+    # download the dataset.
+    if args.dataset_name is not None:
+        # Downloading and loading a dataset from the hub.
+        dataset = load_dataset(
+            args.dataset_name,
+            args.dataset_config_name,
+            cache_dir=args.cache_dir,
+        )
+    else:
+        # This branch will not be called
+        data_files = {}
+        if args.train_data_dir is not None:
+            data_files["train"] = os.path.join(args.train_data_dir, "**")
+        dataset = load_dataset(
+            "imagefolder",
+            data_files=data_files,
+            cache_dir=args.cache_dir,
+        )
+        # See more about loading custom images at
+        # https://huggingface.co/docs/datasets/v2.4.0/en/image_load#imagefolder
+
+    # Preprocessing the datasets.
+    # We need to tokenize inputs and targets.
+    column_names = dataset["train"].column_names
+
+    # 6. Get the column names for input/target.
+    dataset_columns = DATASET_NAME_MAPPING.get(args.dataset_name, None)
+    if args.image_column is None:
+        image_column = dataset_columns[0] if dataset_columns is not None else column_names[0]
+    else:
+        image_column = args.image_column
+        if image_column not in column_names:
+            raise ValueError(
+                f"--image_column' value '{args.image_column}' needs to be one of: {', '.join(column_names)}"
+            )
+    if args.caption_column is None:
+        caption_column = dataset_columns[1] if dataset_columns is not None else column_names[1]
+    else:
+        caption_column = args.caption_column
+        if caption_column not in column_names:
+            raise ValueError(
+                f"--caption_column' value '{args.caption_column}' needs to be one of: {', '.join(column_names)}"
+            )
+
+    # Preprocessing the datasets.
+    # We need to tokenize input captions and transform the images.
+    def tokenize_captions(examples, is_train=True):
+        captions = []
+        for caption in examples[caption_column]:
+            if isinstance(caption, str):
+                captions.append(caption)
+            elif isinstance(caption, (list, np.ndarray)):
+                # take a random caption if there are multiple
+                captions.append(random.choice(caption) if is_train else caption[0])
+            else:
+                raise ValueError(
+                    f"Caption column `{caption_column}` should contain either strings or lists of strings."
+                )
+        inputs = tokenizer(
+            captions, max_length=tokenizer.model_max_length, padding="max_length", truncation=True, return_tensors="pt"
+        )
+        return inputs.input_ids
+
+    # Preprocessing the datasets.
+    train_transforms = transforms.Compose(
+        [
+            #transforms.Resize(args.resolution, interpolation=transforms.InterpolationMode.BILINEAR),
+            #transforms.CenterCrop(args.resolution) if args.center_crop else transforms.RandomCrop(args.resolution),
+            FaceCrop(),
+            transforms.Resize(args.resolution, interpolation=transforms.InterpolationMode.BILINEAR),
+            transforms.RandomHorizontalFlip() if args.random_flip else transforms.Lambda(lambda x: x),
+            transforms.ToTensor(),
+            transforms.Normalize([0.5], [0.5]),
+        ]
+    )
+
+    def preprocess_train(examples):
+        images = [image.convert("RGB") for image in examples[image_column]]
+        examples["pixel_values"] = [train_transforms(image) for image in images]
+        examples["input_ids"] = tokenize_captions(examples)
+        return examples
+
+    with accelerator.main_process_first():
+        if args.max_train_samples is not None:
+            dataset["train"] = dataset["train"].shuffle(seed=args.seed).select(range(args.max_train_samples))
+        # Set the training transforms
+        train_dataset = dataset["train"].with_transform(preprocess_train)
+
+    def collate_fn(examples):
+        pixel_values = torch.stack([example["pixel_values"] for example in examples])
+        pixel_values = pixel_values.to(memory_format=torch.contiguous_format).float()
+        input_ids = torch.stack([example["input_ids"] for example in examples])
+        return {"pixel_values": pixel_values, "input_ids": input_ids}
+
+    # DataLoaders creation:
+    train_dataloader = torch.utils.data.DataLoader(
+        train_dataset,
+        shuffle=True,
+        collate_fn=collate_fn,
+        batch_size=args.train_batch_size,
+        num_workers=args.dataloader_num_workers,
+    )
+
+    # Scheduler and math around the number of training steps.
+    overrode_max_train_steps = False
+    num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
+    if args.max_train_steps is None:
+        args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
+        overrode_max_train_steps = True
+
+    lr_scheduler = get_scheduler(
+        args.lr_scheduler,
+        optimizer=optimizer,
+        num_warmup_steps=args.lr_warmup_steps * accelerator.num_processes,
+        num_training_steps=args.max_train_steps * accelerator.num_processes,
+    )
+
+    # Prepare everything with our `accelerator`.
+    if args.use_peft:
+        if args.train_text_encoder:
+            unet, text_encoder, optimizer, train_dataloader, lr_scheduler = accelerator.prepare(
+                unet, text_encoder, optimizer, train_dataloader, lr_scheduler
+            )
+        else:
+            unet, optimizer, train_dataloader, lr_scheduler = accelerator.prepare(
+                unet, optimizer, train_dataloader, lr_scheduler
+            )
+    else:
+        lora_layers, optimizer, train_dataloader, lr_scheduler = accelerator.prepare(
+            lora_layers, optimizer, train_dataloader, lr_scheduler
+        )
+    unet = unet.cuda()
+    # We need to recalculate our total training steps as the size of the training dataloader may have changed.
+    num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
+    if overrode_max_train_steps:
+        args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
+    # Afterwards we recalculate our number of training epochs
+    args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch)
+
+    # We need to initialize the trackers we use, and also store our configuration.
+    # The trackers initializes automatically on the main process.
+    if accelerator.is_main_process:
+        accelerator.init_trackers("text2image-fine-tune", config=vars(args))
+
+    # Train!
+    total_batch_size = args.train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps
+
+    logger.info("***** Running training *****")
+    logger.info(f"  Num examples = {len(train_dataset)}")
+    logger.info(f"  Num Epochs = {args.num_train_epochs}")
+    logger.info(f"  Instantaneous batch size per device = {args.train_batch_size}")
+    logger.info(f"  Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}")
+    logger.info(f"  Gradient Accumulation steps = {args.gradient_accumulation_steps}")
+    logger.info(f"  Total optimization steps = {args.max_train_steps}")
+    global_step = 0
+    first_epoch = 0
+
+    # Potentially load in the weights and states from a previous save
+    if args.resume_from_checkpoint:
+        if args.resume_from_checkpoint == 'fromfacecommon':
+            weight_model_dir = snapshot_download('damo/face_frombase_c4',
+                                                 revision='v1.0.0',
+                                                 user_agent={'invoked_by': 'trainer', 'third_party': 'facechain'})
+            path = os.path.join(weight_model_dir, 'face_frombase_c4.bin')
+        elif args.resume_from_checkpoint != "latest":
+            path = os.path.basename(args.resume_from_checkpoint)
+        else:
+            # Get the most recent checkpoint
+            dirs = os.listdir(args.output_dir)
+            dirs = [d for d in dirs if d.startswith("checkpoint")]
+            dirs = sorted(dirs, key=lambda x: int(x.split("-")[1]))
+            path = dirs[-1] if len(dirs) > 0 else None
+
+        if path is None:
+            accelerator.print(
+                f"Checkpoint '{args.resume_from_checkpoint}' does not exist. Starting a new training run."
+            )
+            args.resume_from_checkpoint = None
+        else:
+            if args.resume_from_checkpoint == 'fromfacecommon':
+                accelerator.print(f"Resuming from checkpoint {path}")
+                unet_state_dict = torch.load(path, map_location='cpu')
+                accelerator._models[-1].load_state_dict(unet_state_dict)
+                global_step = 0
+            else:
+                accelerator.print(f"Resuming from checkpoint {path}")
+                accelerator.load_state(os.path.join(args.output_dir, path))
+                global_step = int(path.split("-")[1])
+
+            resume_global_step = global_step * args.gradient_accumulation_steps
+            first_epoch = global_step // num_update_steps_per_epoch
+            resume_step = resume_global_step % (num_update_steps_per_epoch * args.gradient_accumulation_steps)
+
+    # Only show the progress bar once on each machine.
+    progress_bar = tqdm(range(global_step, args.max_train_steps), disable=not accelerator.is_local_main_process)
+    progress_bar.set_description("Steps")
+
+    for epoch in range(first_epoch, args.num_train_epochs):
+        unet.train()
+        if args.train_text_encoder:
+            text_encoder.train()
+        train_loss = 0.0
+        for step, batch in enumerate(train_dataloader):
+            # Skip steps until we reach the resumed step
+            if args.resume_from_checkpoint and epoch == first_epoch and step < resume_step:
+                if step % args.gradient_accumulation_steps == 0:
+                    progress_bar.update(1)
+                continue
+
+            with accelerator.accumulate(unet):
+                # Convert images to latent space
+                latents = vae.encode(batch["pixel_values"].to(dtype=weight_dtype)).latent_dist.sample()
+                latents = latents * vae.config.scaling_factor
+
+                # Sample noise that we'll add to the latents
+                noise = torch.randn_like(latents)
+                bsz = latents.shape[0]
+                # Sample a random timestep for each image
+                timesteps = torch.randint(0, noise_scheduler.config.num_train_timesteps, (bsz,), device=latents.device)
+                timesteps = timesteps.long()
+
+                # Add noise to the latents according to the noise magnitude at each timestep
+                # (this is the forward diffusion process)
+                noisy_latents = noise_scheduler.add_noise(latents, noise, timesteps)
+
+                # Get the text embedding for conditioning
+                encoder_hidden_states = text_encoder(batch["input_ids"])[0]
+
+                # Get the target for loss depending on the prediction type
+                if noise_scheduler.config.prediction_type == "epsilon":
+                    target = noise
+                elif noise_scheduler.config.prediction_type == "v_prediction":
+                    target = noise_scheduler.get_velocity(latents, noise, timesteps)
+                else:
+                    raise ValueError(f"Unknown prediction type {noise_scheduler.config.prediction_type}")
+
+                # Predict the noise residual and compute loss
+                model_pred = unet(noisy_latents, timesteps, encoder_hidden_states).sample
+                loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean")
+
+                # Gather the losses across all processes for logging (if we use distributed training).
+                avg_loss = accelerator.gather(loss.repeat(args.train_batch_size)).mean()
+                train_loss += avg_loss.item() / args.gradient_accumulation_steps
+
+                # Backpropagate
+                accelerator.backward(loss)
+                if accelerator.sync_gradients:
+                    if args.use_peft:
+                        params_to_clip = (
+                            itertools.chain(unet.parameters(), text_encoder.parameters())
+                            if args.train_text_encoder
+                            else unet.parameters()
+                        )
+                    else:
+                        params_to_clip = lora_layers.parameters()
+                    accelerator.clip_grad_norm_(params_to_clip, args.max_grad_norm)
+                optimizer.step()
+                lr_scheduler.step()
+                optimizer.zero_grad()
+
+            # Checks if the accelerator has performed an optimization step behind the scenes
+            if accelerator.sync_gradients:
+                progress_bar.update(1)
+                global_step += 1
+                accelerator.log({"train_loss": train_loss}, step=global_step)
+                train_loss = 0.0
+
+                if global_step % args.checkpointing_steps == 0:
+                    if accelerator.is_main_process:
+                        save_path = os.path.join(args.output_dir, f"checkpoint-{global_step}")
+                        accelerator.save_state(save_path)
+                        logger.info(f"Saved state to {save_path}")
+
+            logs = {"step_loss": loss.detach().item(), "lr": lr_scheduler.get_last_lr()[0]}
+            progress_bar.set_postfix(**logs)
+
+            if global_step >= args.max_train_steps:
+                break
+
+
+        if accelerator.is_main_process:
+            if args.validation_prompt is not None and epoch % args.validation_epochs == 0:
+                logger.info(
+                    f"Running validation... \n Generating {args.num_validation_images} images with prompt:"
+                    f" {args.validation_prompt}."
+                )
+                pipeline = DiffusionPipeline.from_pretrained(
+                    model_dir,
+                    unet=accelerator.unwrap_model(unet),
+                    text_encoder=accelerator.unwrap_model(text_encoder),
+                    torch_dtype=weight_dtype,
+                )
+                pipeline = pipeline.to(accelerator.device)
+                pipeline.set_progress_bar_config(disable=True)
+
+                # run inference
+                generator = torch.Generator(device=accelerator.device).manual_seed(args.seed)
+                images = []
+                for _ in range(args.num_validation_images):
+                    images.append(
+                        pipeline(args.validation_prompt, num_inference_steps=30, generator=generator).images[0]
+                    )
+
+                if accelerator.is_main_process:
+                    for tracker in accelerator.trackers:
+                        if tracker.name == "tensorboard":
+                            np_images = np.stack([np.asarray(img) for img in images])
+                            tracker.writer.add_images("validation", np_images, epoch, dataformats="NHWC")
+                        if tracker.name == "wandb":
+                            tracker.log(
+                                {
+                                    "validation": [
+                                        wandb.Image(image, caption=f"{i}: {args.validation_prompt}")
+                                        for i, image in enumerate(images)
+                                    ]
+                                }
+                            )
+
+                del pipeline
+                torch.cuda.empty_cache() 
+
+    # Save the lora layers
+    accelerator.wait_for_everyone()
+    if accelerator.is_main_process:
+        if args.use_peft:
+            lora_config = {}
+            unwarpped_unet = accelerator.unwrap_model(unet)
+            state_dict = get_peft_model_state_dict(unwarpped_unet, state_dict=accelerator.get_state_dict(unet))
+            lora_config["peft_config"] = unwarpped_unet.get_peft_config_as_dict(inference=True)
+            if args.train_text_encoder:
+                unwarpped_text_encoder = accelerator.unwrap_model(text_encoder)
+                text_encoder_state_dict = get_peft_model_state_dict(
+                    unwarpped_text_encoder, state_dict=accelerator.get_state_dict(text_encoder)
+                )
+                text_encoder_state_dict = {f"text_encoder_{k}": v for k, v in text_encoder_state_dict.items()}
+                state_dict.update(text_encoder_state_dict)
+                lora_config["text_encoder_peft_config"] = unwarpped_text_encoder.get_peft_config_as_dict(
+                    inference=True
+                )
+
+            accelerator.save(state_dict, os.path.join(args.output_dir, f"{global_step}_lora.pt"))
+            with open(os.path.join(args.output_dir, f"{global_step}_lora_config.json"), "w") as f:
+                json.dump(lora_config, f)
+        else:
+            unet = unet.to(torch.float32)
+            unet.save_attn_procs(args.output_dir, safe_serialization=False)
+
+        if args.push_to_hub:
+            save_model_card(
+                repo_id,
+                images=images,
+                base_model=model_dir,
+                dataset_name=args.dataset_name,
+                repo_folder=args.output_dir,
+            )
+            upload_folder(
+                repo_id=repo_id,
+                folder_path=args.output_dir,
+                commit_message="End of training",
+                ignore_patterns=["step_*", "epoch_*"],
+            )
+
+    # Final inference
+    # Load previous pipeline
+    pipeline = DiffusionPipeline.from_pretrained(
+        model_dir, torch_dtype=weight_dtype
+    )
+
+    if args.use_peft:
+        def load_and_set_lora_ckpt(pipe, ckpt_dir, global_step, device, dtype):
+            with open(os.path.join(args.output_dir, f"{global_step}_lora_config.json"), "r") as f:
+                lora_config = json.load(f)
+            print(lora_config)
+
+            checkpoint = os.path.join(args.output_dir, f"{global_step}_lora.pt")
+            lora_checkpoint_sd = torch.load(checkpoint)
+            unet_lora_ds = {k: v for k, v in lora_checkpoint_sd.items() if "text_encoder_" not in k}
+            text_encoder_lora_ds = {
+                k.replace("text_encoder_", ""): v for k, v in lora_checkpoint_sd.items() if "text_encoder_" in k
+            }
+
+            unet_config = LoraConfig(**lora_config["peft_config"])
+            pipe.unet = LoraModel(unet_config, pipe.unet)
+            set_peft_model_state_dict(pipe.unet, unet_lora_ds)
+
+            if "text_encoder_peft_config" in lora_config:
+                text_encoder_config = LoraConfig(**lora_config["text_encoder_peft_config"])
+                pipe.text_encoder = LoraModel(text_encoder_config, pipe.text_encoder)
+                set_peft_model_state_dict(pipe.text_encoder, text_encoder_lora_ds)
+
+            if dtype in (torch.float16, torch.bfloat16):
+                pipe.unet.half()
+                pipe.text_encoder.half()
+
+            pipe.to(device)
+            return pipe
+
+        pipeline = load_and_set_lora_ckpt(pipeline, args.output_dir, global_step, accelerator.device, weight_dtype)
+
+    else:
+        pipeline = pipeline.to(accelerator.device)
+        # load attention processors
+        pipeline.unet.load_attn_procs(args.output_dir)
+
+    # run inference
+    if args.seed is not None:
+        generator = torch.Generator(device=accelerator.device).manual_seed(args.seed)
+    else:
+        generator = None
+    images = []
+
+    accelerator.end_training()
+
+
+if __name__ == "__main__":
+    multiprocessing.set_start_method('spawn')
+    main()

facechain/facechain/utils.py

@@ -0,0 +1,37 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+
+import time
+from modelscope import snapshot_download as ms_snapshot_download
+
+
+def max_retries(max_attempts):
+    def decorator(func):
+        def wrapper(*args, **kwargs):
+            attempts = 0
+            while attempts < max_attempts:
+                try:
+                    return func(*args, **kwargs)
+                except Exception as e:
+                    attempts += 1
+                    print(f"Retry {attempts}/{max_attempts}: {e}")
+                    # wait 1 sec
+                    time.sleep(1)
+            raise Exception(f"Max retries ({max_attempts}) exceeded.")
+        return wrapper
+    return decorator
+
+
+@max_retries(3)
+def snapshot_download(*args, **kwargs):
+    return ms_snapshot_download(*args, **kwargs)
+
+
+def pre_download_models():
+    snapshot_download('ly261666/cv_portrait_model', revision='v4.0')
+    snapshot_download('YorickHe/majicmixRealistic_v6', revision='v1.0.0')
+    snapshot_download('damo/face_chain_control_model', revision='v1.0.1')
+    snapshot_download('ly261666/cv_wanx_style_model', revision='v1.0.3')
+    snapshot_download('damo/face_chain_control_model', revision='v1.0.1')
+    snapshot_download('Cherrytest/zjz_mj_jiyi_small_addtxt_fromleo', revision='v1.0.0')
+    snapshot_download('Cherrytest/rot_bgr', revision='v1.0.0')
+    snapshot_download('damo/face_frombase_c4', revision='v1.0.0')

facechain/facechain_demo.ipynb

@@ -0,0 +1,181 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+  "colab": {
+   "private_outputs": true,
+   "provenance": [],
+   "machine_shape": "hm",
+   "name": "facechain-demo.ipynb"
+  },
+  "kernelspec": {
+   "name": "python3",
+   "display_name": "Python 3"
+  }
+ },
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "source": [
+    "Requirements:\n",
+    "- GPU Mem Usage: 19G\n",
+    "- Disk Usage: About 50G"
+   ],
+   "metadata": {
+    "id": "AzOycrSUkK-0"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## Get facechain source code from GitHub"
+   ],
+   "metadata": {
+    "id": "8yQEWTkekIx9"
+   }
+  },
+  {
+   "cell_type": "code",
+   "source": [
+    "!GIT_LFS_SKIP_SMUDGE=1 git clone https://github.com/modelscope/facechain.git --depth 1"
+   ],
+   "metadata": {
+    "id": "WK_uDw0NkHTP"
+   },
+   "execution_count": null,
+   "outputs": []
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## Installation requirements\n",
+    "- Note that you can ignore warning on dependencies conflicts at the end\n",
+    "- You may use conda virtual env to avoid warning info."
+   ],
+   "metadata": {
+    "id": "jUWWSGDG1ZGK"
+   }
+  },
+  {
+   "cell_type": "code",
+   "source": [
+    "!pip3 install -r facechain/requirements.txt"
+   ],
+   "metadata": {
+    "id": "QrwRDBipxKZw"
+   },
+   "execution_count": null,
+   "outputs": []
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## Check environment informaiton"
+   ],
+   "metadata": {
+    "id": "0miaB1nC2VrA"
+   }
+  },
+  {
+   "cell_type": "code",
+   "source": [
+    "!nvidia-smi\n",
+    "!pip3 show torch\n",
+    "\n",
+    "# Note that this setup is verified on (cuda 12.0, torch2.0.1+cu118, Nvidia-A100 40G)"
+   ],
+   "metadata": {
+    "id": "uvNE0kRxyI4q"
+   },
+   "execution_count": null,
+   "outputs": []
+  },
+  {
+   "cell_type": "markdown",
+   "source": [],
+   "metadata": {
+    "id": "klba298h2bbu"
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## Installing mmcv-full\n",
+    "- Several of the underlying models depend on mmcv-full, which could be tricky to install since it is environment-dependent, you may refer to [mmcv's official documentation](https://mmcv.readthedocs.io/zh_CN/latest/get_started/installation.html) for more details..\n",
+    "- A prebuilt package is provided here for convenience, and was verified on (cuda 12.0, torch2.0.1+cu118, Nvidia-A100 40G)\n",
+    "- If the prebuilt package does not work on your env setup, please use the alternative installation as suggested by [mmcv's official documentation](https://mmcv.readthedocs.io/zh_CN/latest/get_started/)"
+   ],
+   "metadata": {
+    "id": "ciSxxSzI4l_u"
+   }
+  },
+  {
+   "cell_type": "code",
+   "source": [
+    "# use prebuilt mmcv-full package provided by ModelScope (verified on cuda 12.0, torch2.0.1+cu118, Nvidia-A100 40G)\n",
+    "!pip3 install https://modelscope.oss-cn-beijing.aliyuncs.com/packages/mmcv/mmcv_full-1.7.0-cp310-cp310-linux_x86_64.whl\n",
+    "\n",
+    "# alternative manual installtation. note that it may take 30+ mins for building dependencies.\n",
+    "# !pip3 install -U openmim\n",
+    "# !mim install mmcv-full==1.7.0\n"
+   ],
+   "metadata": {
+    "id": "t2lciBXyyuzA"
+   },
+   "execution_count": null,
+   "outputs": []
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## Pre-download models to mitigate connection timeout issue"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "os.chdir('/content/facechain') # Note: replace with your facechain root\n",
+    "print(os.getcwd())\n",
+    "\n",
+    "# Not required\n",
+    "from facechain.utils import pre_download_models\n",
+    "pre_download_models()"
+   ],
+   "metadata": {
+    "collapsed": false
+   }
+  },
+  {
+   "cell_type": "markdown",
+   "source": [
+    "## Start facechain WebUI service"
+   ],
+   "metadata": {
+    "id": "OxDgRY8H4vta"
+   }
+  },
+  {
+   "cell_type": "code",
+   "source": [
+    "# Install service dependencies\n",
+    "!pip3 install gradio\n",
+    "!pip3 install controlnet_aux==0.0.6\n",
+    "!pip3 install python-slugify\n",
+    "\n",
+    "# Click on the gradio URL to start building your FaceChain digital-twin!\n",
+    "!python3 app.py"
+   ],
+   "metadata": {
+    "id": "NW5o0iiezTCg"
+   },
+   "execution_count": null,
+   "outputs": []
+  }
+ ]
+}

facechain/requirements.txt

@@ -0,0 +1,22 @@
+accelerate
+transformers
+diffusers
+onnxruntime
+modelscope
+Pillow
+opencv-python
+torchvision
+mmdet==2.26.0
+mmengine
+numpy==1.22.0
+protobuf==3.20.1
+timm
+scikit-image
+gradio
+controlnet_aux==0.0.6
+mediapipe
+python-slugify
+#tensorflow==2.8.0
+#tensorflow-cpu  # slower but no cuda conflicts
+
+# mmcv-full (need mim install)

facechain/resources/awesome-prompts-facechain.txt

@@ -0,0 +1,14 @@
+# style model: default
+an elegant evening gown, upper_body, best quality, Professional
+
+# style model: default
+beautiful traditional hanfu, upper_body, best quality, Professional
+
+# style model: default
+The lord of the rings, ELF, Arwen Undomiel, beautiful, upper_body, best quality, Professional
+
+# style model: default
+Beautiful and cute girl, 16 years old, denim jacket, gradient background, soft colors, soft lighting, cinematic edge lighting, light and dark contrast, anime, art station Seraflur, blind box, super detail, 8k，--iw 1
+
+# style model: default
+beautiful woman, realistic, Dappled Light, analog style, cinematic light, sidelighting, ultra high res, best shadow, RAW, beautiful hair, designer jacket, fashionable pants, turtleneck shirt, fall forest, Looking over the shoulder pose, professional model photoshoot, hdr, sunset

facechain/run_inference.py

@@ -0,0 +1,72 @@
+# Copyright (c) Alibaba, Inc. and its affiliates.
+import os
+
+from facechain.inference import GenPortrait
+import cv2
+from facechain.utils import snapshot_download
+from facechain.constants import neg_prompt, pos_prompt_with_cloth, pos_prompt_with_style, styles, base_models
+
+
+def generate_pos_prompt(style_model, prompt_cloth):
+    if style_model in base_models[0]['style_list'][:-1] or style_model is None:
+        pos_prompt = pos_prompt_with_cloth.format(prompt_cloth)
+    else:
+        matched = list(filter(lambda style: style_model == style['name'], styles))
+        if len(matched) == 0:
+            raise ValueError(f'styles not found: {style_model}')
+        matched = matched[0]
+        pos_prompt = pos_prompt_with_style.format(matched['add_prompt_style'])
+    return pos_prompt
+
+
+use_main_model = True
+use_face_swap = True
+use_post_process = True
+use_stylization = False
+use_depth_control = False
+use_pose_model = False
+pose_image = 'poses/man/pose1.png'
+processed_dir = './processed'
+num_generate = 5
+base_model = 'ly261666/cv_portrait_model'
+revision = 'v2.0'
+multiplier_style = 0.25
+multiplier_human = 0.85
+base_model_sub_dir = 'film/film'
+train_output_dir = './output'
+output_dir = './generated'
+style = styles[0]
+model_id = style['model_id']
+
+if model_id == None:
+    style_model_path = None
+    pos_prompt = generate_pos_prompt(style['name'], style['add_prompt_style'])
+else:
+    if os.path.exists(model_id):
+        model_dir = model_id
+    else:
+        model_dir = snapshot_download(model_id, revision=style['revision'])
+    style_model_path = os.path.join(model_dir, style['bin_file'])
+    pos_prompt = generate_pos_prompt(style['name'], style['add_prompt_style'])  # style has its own prompt
+
+if not use_pose_model:
+    pose_model_path = None
+    use_depth_control = False
+    pose_image = None
+else:
+    model_dir = snapshot_download('damo/face_chain_control_model', revision='v1.0.1')
+    pose_model_path = os.path.join(model_dir, 'model_controlnet/control_v11p_sd15_openpose')
+
+gen_portrait = GenPortrait(pose_model_path, pose_image, use_depth_control, pos_prompt, neg_prompt, style_model_path,
+                           multiplier_style, multiplier_human, use_main_model,
+                           use_face_swap, use_post_process,
+                           use_stylization)
+
+outputs = gen_portrait(processed_dir, num_generate, base_model,
+                       train_output_dir, base_model_sub_dir, revision)
+
+os.makedirs(output_dir, exist_ok=True)
+
+for i, out_tmp in enumerate(outputs):
+    cv2.imwrite(os.path.join(output_dir, f'{i}.png'), out_tmp)
+