Upload 948 files

.gitattributes

@@ -33,3 +33,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+TryYours-Virtual-Try-On/HR-VITON-main/figures/fig.jpg filter=lfs diff=lfs merge=lfs -text
+TryYours-Virtual-Try-On/HR-VITON-main/Output/00001_00_00001_00.png filter=lfs diff=lfs merge=lfs -text
+TryYours-Virtual-Try-On/static/finalimg.png filter=lfs diff=lfs merge=lfs -text
+TryYours-Virtual-Try-On/static/origin_web.jpg filter=lfs diff=lfs merge=lfs -text
+TryYours-Virtual-Try-On/TryYours_presentation_kr.pdf filter=lfs diff=lfs merge=lfs -text

TryYours-Virtual-Try-On/.gitignore

@@ -0,0 +1,5 @@
+# don't upload large pth files
+
+HR-VITON-main/gen.pth
+HR-VITON-main/mtviton.pth
+Graphonomy-master/inference.pth

TryYours-Virtual-Try-On/Demo.ipynb

@@ -0,0 +1,267 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "803b037a-183e-46e4-bfde-a144dc779cf0",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2022-12-29T07:03:01.120935Z",
+     "iopub.status.busy": "2022-12-29T07:03:01.120639Z",
+     "iopub.status.idle": "2022-12-29T07:03:03.538100Z",
+     "shell.execute_reply": "2022-12-29T07:03:03.537115Z",
+     "shell.execute_reply.started": "2022-12-29T07:03:01.120878Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Collecting tensorboardX\n",
+      "  Downloading tensorboardX-2.5.1-py2.py3-none-any.whl (125 kB)\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m125.4/125.4 kB\u001b[0m \u001b[31m23.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[?25hRequirement already satisfied: numpy in /usr/local/lib/python3.9/dist-packages (from tensorboardX) (1.23.1)\n",
+      "Requirement already satisfied: protobuf<=3.20.1,>=3.8.0 in /usr/local/lib/python3.9/dist-packages (from tensorboardX) (3.19.4)\n",
+      "Installing collected packages: tensorboardX\n",
+      "Successfully installed tensorboardX-2.5.1\n",
+      "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n",
+      "\u001b[0m"
+     ]
+    }
+   ],
+   "source": [
+    "!pip install tensorboardX av torchgeometry flask flask-ngrok iglovikov_helper_functions cloths_segmentation albumentations"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "756d9b98-41d4-4f4f-85bc-51c77b99507c",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2022-12-29T07:07:46.679818Z",
+     "iopub.status.busy": "2022-12-29T07:07:46.679527Z",
+     "iopub.status.idle": "2022-12-29T07:10:34.279721Z",
+     "shell.execute_reply": "2022-12-29T07:10:34.278988Z",
+     "shell.execute_reply.started": "2022-12-29T07:07:46.679796Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Collecting git+https://github.com/facebookresearch/detectron2.git\n",
+      "  Cloning https://github.com/facebookresearch/detectron2.git to /tmp/pip-req-build-llo0z_rd\n",
+      "  Running command git clone --filter=blob:none --quiet https://github.com/facebookresearch/detectron2.git /tmp/pip-req-build-llo0z_rd\n",
+      "  Resolved https://github.com/facebookresearch/detectron2.git to commit 857d5de21a7789d1bba46694cf608b1cb2ea128a\n",
+      "  Preparing metadata (setup.py) ... \u001b[?25ldone\n",
+      "\u001b[?25hRequirement already satisfied: Pillow>=7.1 in /usr/local/lib/python3.9/dist-packages (from detectron2==0.6) (9.2.0)\n",
+      "Requirement already satisfied: matplotlib in /usr/local/lib/python3.9/dist-packages (from detectron2==0.6) (3.5.2)\n",
+      "Collecting pycocotools>=2.0.2\n",
+      "  Downloading pycocotools-2.0.6.tar.gz (24 kB)\n",
+      "  Installing build dependencies ... \u001b[?25ldone\n",
+      "\u001b[?25h  Getting requirements to build wheel ... \u001b[?25ldone\n",
+      "\u001b[?25h  Preparing metadata (pyproject.toml) ... \u001b[?25ldone\n",
+      "\u001b[?25hRequirement already satisfied: termcolor>=1.1 in /usr/local/lib/python3.9/dist-packages (from detectron2==0.6) (1.1.0)\n",
+      "Collecting yacs>=0.1.8\n",
+      "  Downloading yacs-0.1.8-py3-none-any.whl (14 kB)\n",
+      "Collecting tabulate\n",
+      "  Downloading tabulate-0.9.0-py3-none-any.whl (35 kB)\n",
+      "Requirement already satisfied: cloudpickle in /usr/local/lib/python3.9/dist-packages (from detectron2==0.6) (2.1.0)\n",
+      "Requirement already satisfied: tqdm>4.29.0 in /usr/local/lib/python3.9/dist-packages (from detectron2==0.6) (4.64.0)\n",
+      "Requirement already satisfied: tensorboard in /usr/local/lib/python3.9/dist-packages (from detectron2==0.6) (2.9.1)\n",
+      "Collecting fvcore<0.1.6,>=0.1.5\n",
+      "  Downloading fvcore-0.1.5.post20221221.tar.gz (50 kB)\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m50.2/50.2 kB\u001b[0m \u001b[31m15.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[?25h  Preparing metadata (setup.py) ... \u001b[?25ldone\n",
+      "\u001b[?25hCollecting iopath<0.1.10,>=0.1.7\n",
+      "  Downloading iopath-0.1.9-py3-none-any.whl (27 kB)\n",
+      "Collecting omegaconf>=2.1\n",
+      "  Downloading omegaconf-2.3.0-py3-none-any.whl (79 kB)\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m79.5/79.5 kB\u001b[0m \u001b[31m20.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[?25hCollecting hydra-core>=1.1\n",
+      "  Downloading hydra_core-1.3.1-py3-none-any.whl (154 kB)\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m154.1/154.1 kB\u001b[0m \u001b[31m31.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[?25hCollecting black\n",
+      "  Downloading black-22.12.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.6 MB)\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.6/1.6 MB\u001b[0m \u001b[31m82.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[?25hCollecting timm\n",
+      "  Downloading timm-0.6.12-py3-none-any.whl (549 kB)\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m549.1/549.1 kB\u001b[0m \u001b[31m51.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[?25hRequirement already satisfied: packaging in /usr/local/lib/python3.9/dist-packages (from detectron2==0.6) (21.3)\n",
+      "Requirement already satisfied: numpy in /usr/local/lib/python3.9/dist-packages (from fvcore<0.1.6,>=0.1.5->detectron2==0.6) (1.23.1)\n",
+      "Requirement already satisfied: pyyaml>=5.1 in /usr/local/lib/python3.9/dist-packages (from fvcore<0.1.6,>=0.1.5->detectron2==0.6) (5.4.1)\n",
+      "Collecting antlr4-python3-runtime==4.9.*\n",
+      "  Downloading antlr4-python3-runtime-4.9.3.tar.gz (117 kB)\n",
+      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m117.0/117.0 kB\u001b[0m \u001b[31m28.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+      "\u001b[?25h  Preparing metadata (setup.py) ... \u001b[?25ldone\n",
+      "\u001b[?25hCollecting portalocker\n",
+      "  Downloading portalocker-2.6.0-py2.py3-none-any.whl (15 kB)\n",
+      "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.9/dist-packages (from matplotlib->detectron2==0.6) (0.11.0)\n",
+      "Requirement already satisfied: pyparsing>=2.2.1 in /usr/local/lib/python3.9/dist-packages (from matplotlib->detectron2==0.6) (3.0.9)\n",
+      "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.9/dist-packages (from matplotlib->detectron2==0.6) (2.8.2)\n",
+      "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.9/dist-packages (from matplotlib->detectron2==0.6) (4.34.4)\n",
+      "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.9/dist-packages (from matplotlib->detectron2==0.6) (1.4.3)\n",
+      "Collecting mypy-extensions>=0.4.3\n",
+      "  Downloading mypy_extensions-0.4.3-py2.py3-none-any.whl (4.5 kB)\n",
+      "Collecting pathspec>=0.9.0\n",
+      "  Downloading pathspec-0.10.3-py3-none-any.whl (29 kB)\n",
+      "Collecting platformdirs>=2\n",
+      "  Downloading platformdirs-2.6.2-py3-none-any.whl (14 kB)\n",
+      "Requirement already satisfied: click>=8.0.0 in /usr/local/lib/python3.9/dist-packages (from black->detectron2==0.6) (8.1.3)\n",
+      "Collecting tomli>=1.1.0\n",
+      "  Downloading tomli-2.0.1-py3-none-any.whl (12 kB)\n",
+      "Requirement already satisfied: typing-extensions>=3.10.0.0 in /usr/local/lib/python3.9/dist-packages (from black->detectron2==0.6) (4.3.0)\n",
+      "Requirement already satisfied: tensorboard-data-server<0.7.0,>=0.6.0 in /usr/local/lib/python3.9/dist-packages (from tensorboard->detectron2==0.6) (0.6.1)\n",
+      "Requirement already satisfied: werkzeug>=1.0.1 in /usr/local/lib/python3.9/dist-packages (from tensorboard->detectron2==0.6) (2.2.2)\n",
+      "Requirement already satisfied: tensorboard-plugin-wit>=1.6.0 in /usr/local/lib/python3.9/dist-packages (from tensorboard->detectron2==0.6) (1.8.1)\n",
+      "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.9/dist-packages (from tensorboard->detectron2==0.6) (3.3.7)\n",
+      "Requirement already satisfied: protobuf<3.20,>=3.9.2 in /usr/local/lib/python3.9/dist-packages (from tensorboard->detectron2==0.6) (3.19.4)\n",
+      "Requirement already satisfied: setuptools>=41.0.0 in /usr/local/lib/python3.9/dist-packages (from tensorboard->detectron2==0.6) (63.1.0)\n",
+      "Requirement already satisfied: requests<3,>=2.21.0 in /usr/local/lib/python3.9/dist-packages (from tensorboard->detectron2==0.6) (2.28.1)\n",
+      "Requirement already satisfied: google-auth-oauthlib<0.5,>=0.4.1 in /usr/local/lib/python3.9/dist-packages (from tensorboard->detectron2==0.6) (0.4.6)\n",
+      "Requirement already satisfied: google-auth<3,>=1.6.3 in /usr/local/lib/python3.9/dist-packages (from tensorboard->detectron2==0.6) (2.9.0)\n",
+      "Requirement already satisfied: grpcio>=1.24.3 in /usr/local/lib/python3.9/dist-packages (from tensorboard->detectron2==0.6) (1.47.0)\n",
+      "Requirement already satisfied: wheel>=0.26 in /usr/local/lib/python3.9/dist-packages (from tensorboard->detectron2==0.6) (0.35.1)\n",
+      "Requirement already satisfied: absl-py>=0.4 in /usr/local/lib/python3.9/dist-packages (from tensorboard->detectron2==0.6) (1.1.0)\n",
+      "Requirement already satisfied: torchvision in /usr/local/lib/python3.9/dist-packages (from timm->detectron2==0.6) (0.13.0+cu116)\n",
+      "Requirement already satisfied: huggingface-hub in /usr/local/lib/python3.9/dist-packages (from timm->detectron2==0.6) (0.8.1)\n",
+      "Requirement already satisfied: torch>=1.7 in /usr/local/lib/python3.9/dist-packages (from timm->detectron2==0.6) (1.12.0+cu116)\n",
+      "Requirement already satisfied: pyasn1-modules>=0.2.1 in /usr/local/lib/python3.9/dist-packages (from google-auth<3,>=1.6.3->tensorboard->detectron2==0.6) (0.2.8)\n",
+      "Requirement already satisfied: cachetools<6.0,>=2.0.0 in /usr/local/lib/python3.9/dist-packages (from google-auth<3,>=1.6.3->tensorboard->detectron2==0.6) (5.2.0)\n",
+      "Requirement already satisfied: six>=1.9.0 in /usr/lib/python3/dist-packages (from google-auth<3,>=1.6.3->tensorboard->detectron2==0.6) (1.14.0)\n",
+      "Requirement already satisfied: rsa<5,>=3.1.4 in /usr/lib/python3/dist-packages (from google-auth<3,>=1.6.3->tensorboard->detectron2==0.6) (4.0)\n",
+      "Requirement already satisfied: requests-oauthlib>=0.7.0 in /usr/local/lib/python3.9/dist-packages (from google-auth-oauthlib<0.5,>=0.4.1->tensorboard->detectron2==0.6) (1.3.1)\n",
+      "Requirement already satisfied: importlib-metadata>=4.4 in /usr/local/lib/python3.9/dist-packages (from markdown>=2.6.8->tensorboard->detectron2==0.6) (4.12.0)\n",
+      "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.9/dist-packages (from requests<3,>=2.21.0->tensorboard->detectron2==0.6) (1.26.10)\n",
+      "Requirement already satisfied: charset-normalizer<3,>=2 in /usr/local/lib/python3.9/dist-packages (from requests<3,>=2.21.0->tensorboard->detectron2==0.6) (2.1.0)\n",
+      "Requirement already satisfied: idna<4,>=2.5 in /usr/lib/python3/dist-packages (from requests<3,>=2.21.0->tensorboard->detectron2==0.6) (2.8)\n",
+      "Requirement already satisfied: certifi>=2017.4.17 in /usr/lib/python3/dist-packages (from requests<3,>=2.21.0->tensorboard->detectron2==0.6) (2019.11.28)\n",
+      "Requirement already satisfied: MarkupSafe>=2.1.1 in /usr/local/lib/python3.9/dist-packages (from werkzeug>=1.0.1->tensorboard->detectron2==0.6) (2.1.1)\n",
+      "Requirement already satisfied: filelock in /usr/local/lib/python3.9/dist-packages (from huggingface-hub->timm->detectron2==0.6) (3.7.1)\n",
+      "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.9/dist-packages (from importlib-metadata>=4.4->markdown>=2.6.8->tensorboard->detectron2==0.6) (3.8.1)\n",
+      "Requirement already satisfied: pyasn1<0.5.0,>=0.4.6 in /usr/local/lib/python3.9/dist-packages (from pyasn1-modules>=0.2.1->google-auth<3,>=1.6.3->tensorboard->detectron2==0.6) (0.4.8)\n",
+      "Requirement already satisfied: oauthlib>=3.0.0 in /usr/local/lib/python3.9/dist-packages (from requests-oauthlib>=0.7.0->google-auth-oauthlib<0.5,>=0.4.1->tensorboard->detectron2==0.6) (3.2.0)\n",
+      "Building wheels for collected packages: detectron2, fvcore, antlr4-python3-runtime, pycocotools\n",
+      "  Building wheel for detectron2 (setup.py) ... \u001b[?25ldone\n",
+      "\u001b[?25h  Created wheel for detectron2: filename=detectron2-0.6-cp39-cp39-linux_x86_64.whl size=5889223 sha256=ed1f701e1bc42d870d0d6fafd338e2a8e663f2847c8960619ecf38a4db0338ad\n",
+      "  Stored in directory: /tmp/pip-ephem-wheel-cache-bzzpgw82/wheels/59/b4/83/84bfca751fa4dcc59998468be8688eb50e97408a83af171d42\n",
+      "  Building wheel for fvcore (setup.py) ... \u001b[?25ldone\n",
+      "\u001b[?25h  Created wheel for fvcore: filename=fvcore-0.1.5.post20221221-py3-none-any.whl size=61406 sha256=669c4db5ec6509578bb39829693a8e5438fde1d0116ec668be64bf0261e0eb9f\n",
+      "  Stored in directory: /root/.cache/pip/wheels/83/42/02/66178d16e5c44dc26d309931834956baeda371956e86fbd876\n",
+      "  Building wheel for antlr4-python3-runtime (setup.py) ... \u001b[?25ldone\n",
+      "\u001b[?25h  Created wheel for antlr4-python3-runtime: filename=antlr4_python3_runtime-4.9.3-py3-none-any.whl size=144554 sha256=ddfc41c7e0307f85e68b773551e1be87484cbe4ac68ba04bd4e2dc501dfb6c95\n",
+      "  Stored in directory: /root/.cache/pip/wheels/23/cf/80/f3efa822e6ab23277902ee9165fe772eeb1dfb8014f359020a\n",
+      "  Building wheel for pycocotools (pyproject.toml) ... \u001b[?25ldone\n",
+      "\u001b[?25h  Created wheel for pycocotools: filename=pycocotools-2.0.6-cp39-cp39-linux_x86_64.whl size=400228 sha256=a356c0450d2148ac9d590e3a6adc7b6e913d050be851a84ec830219795200de9\n",
+      "  Stored in directory: /root/.cache/pip/wheels/2f/58/25/e78f1f766e904a9071266661d20d0bc6644df86bcd160aba11\n",
+      "Successfully built detectron2 fvcore antlr4-python3-runtime pycocotools\n",
+      "Installing collected packages: mypy-extensions, antlr4-python3-runtime, yacs, tomli, tabulate, portalocker, platformdirs, pathspec, omegaconf, iopath, hydra-core, black, timm, pycocotools, fvcore, detectron2\n",
+      "Successfully installed antlr4-python3-runtime-4.9.3 black-22.12.0 detectron2-0.6 fvcore-0.1.5.post20221221 hydra-core-1.3.1 iopath-0.1.9 mypy-extensions-0.4.3 omegaconf-2.3.0 pathspec-0.10.3 platformdirs-2.6.2 portalocker-2.6.0 pycocotools-2.0.6 tabulate-0.9.0 timm-0.6.12 tomli-2.0.1 yacs-0.1.8\n",
+      "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n",
+      "\u001b[0m"
+     ]
+    }
+   ],
+   "source": [
+    "!python -m pip install 'git+https://github.com/facebookresearch/detectron2.git'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "ba6c8b48-7243-4602-8c62-862f7a8f00cb",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2022-12-29T07:03:17.515189Z",
+     "iopub.status.busy": "2022-12-29T07:03:17.514793Z",
+     "iopub.status.idle": "2022-12-29T07:03:21.008057Z",
+     "shell.execute_reply": "2022-12-29T07:03:21.006831Z",
+     "shell.execute_reply.started": "2022-12-29T07:03:17.515153Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Collecting pyngrok==4.1.1\n",
+      "  Downloading pyngrok-4.1.1.tar.gz (18 kB)\n",
+      "  Preparing metadata (setup.py) ... \u001b[?25ldone\n",
+      "\u001b[?25hRequirement already satisfied: future in /usr/lib/python3/dist-packages (from pyngrok==4.1.1) (0.18.2)\n",
+      "Requirement already satisfied: PyYAML in /usr/local/lib/python3.9/dist-packages (from pyngrok==4.1.1) (5.4.1)\n",
+      "Building wheels for collected packages: pyngrok\n",
+      "  Building wheel for pyngrok (setup.py) ... \u001b[?25ldone\n",
+      "\u001b[?25h  Created wheel for pyngrok: filename=pyngrok-4.1.1-py3-none-any.whl size=15965 sha256=3669af38b11fcc66e95001ad9cdd77ad1da63d79252e42fe38331b06321ef59d\n",
+      "  Stored in directory: /root/.cache/pip/wheels/89/2d/c2/abe6bcfde6bce368c00ecd73310c11edb672c3eda09a090cfa\n",
+      "Successfully built pyngrok\n",
+      "Installing collected packages: pyngrok\n",
+      "Successfully installed pyngrok-4.1.1\n",
+      "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n",
+      "\u001b[0m"
+     ]
+    }
+   ],
+   "source": [
+    "!pip install pyngrok==4.1.1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "e163eab2-841c-4372-8f75-3d60cbbe247a",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2022-12-29T07:03:21.010722Z",
+     "iopub.status.busy": "2022-12-29T07:03:21.009782Z",
+     "iopub.status.idle": "2022-12-29T07:03:22.584809Z",
+     "shell.execute_reply": "2022-12-29T07:03:22.583859Z",
+     "shell.execute_reply.started": "2022-12-29T07:03:21.010677Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Authtoken saved to configuration file: /root/.ngrok2/ngrok.yml                                      \n"
+     ]
+    }
+   ],
+   "source": [
+    "!ngrok authtoken yourtoken"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "70b46c0a-7f56-4cb0-a84c-836caf911ca4",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

TryYours-Virtual-Try-On/Graphonomy-master/LICENSE

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

TryYours-Virtual-Try-On/Graphonomy-master/README.md

@@ -0,0 +1,124 @@
+# Graphonomy: Universal Human Parsing via Graph Transfer Learning
+
+This repository contains the code for the paper:
+
+[**Graphonomy: Universal Human Parsing via Graph Transfer Learning**](https://arxiv.org/abs/1904.04536)
+,Ke Gong, Yiming Gao, Xiaodan Liang, Xiaohui Shen, Meng Wang, Liang Lin.
+
+
+# Environment and installation
++ Pytorch = 0.4.0
++ torchvision
++ scipy
++ tensorboardX
++ numpy
++ opencv-python
++ matplotlib
++ networkx
+
+   you can install above package by using `pip install -r requirements.txt`
+
+# Getting Started
+### Data Preparation
++ You need to download the human parsing dataset, prepare the images and store in `/data/datasets/dataset_name/`.
+We recommend to symlink the path to the dataets to `/data/dataset/` as follows
+
+```
+# symlink the Pascal-Person-Part dataset for example
+ln -s /path_to_Pascal_Person_Part/* data/datasets/pascal/
+```
++ The file structure should look like:
+```
+/Graphonomy
+  /data
+    /datasets
+      /pascal
+        /JPEGImages
+        /list
+        /SegmentationPart
+      /CIHP_4w
+        /Images
+        /lists
+        ...  
+```
++ The datasets (CIHP & ATR) are available  at [google drive](https://drive.google.com/drive/folders/0BzvH3bSnp3E9ZW9paE9kdkJtM3M?usp=sharing) 
+and [baidu drive](http://pan.baidu.com/s/1nvqmZBN).
+And you also need to download the label with flipped.
+Download [cihp_flipped](https://drive.google.com/file/d/1aaJyQH-hlZEAsA7iH-mYeK1zLfQi8E2j/view?usp=sharing), unzip and store in `data/datasets/CIHP_4w/`. 
+Download [atr_flip](https://drive.google.com/file/d/1iR8Tn69IbDSM7gq_GG-_s11HCnhPkyG3/view?usp=sharing), unzip and store in `data/datasets/ATR/`.
+
+### Inference
+We provide a simply script to get the visualization result on the CIHP dataset using [trained](https://drive.google.com/file/d/1O9YD4kHgs3w2DUcWxtHiEFyWjCBeS_Vc/view?usp=sharing)
+ models as follows :
+```shell
+# Example of inference
+python exp/inference/inference.py  \
+--loadmodel /path_to_inference_model \
+--img_path ./img/messi.jpg \
+--output_path ./img/ \
+--output_name /output_file_name
+``` 
+
+### Training
+#### Transfer learning
+1. Download the Pascal pretrained model(available soon).
+2. Run the `sh train_transfer_cihp.sh`.
+3. The results and models are saved in exp/transfer/run/.
+4. Evaluation and visualization script is eval_cihp.sh. You only need to change the attribute of `--loadmodel` before you run it.
+
+#### Universal training
+1. Download the [pretrained](https://drive.google.com/file/d/18WiffKnxaJo50sCC9zroNyHjcnTxGCbk/view?usp=sharing) model and store in /data/pretrained_model/.
+2. Run the `sh train_universal.sh`.
+3. The results and models are saved in exp/universal/run/.
+
+### Testing 
+If you want to evaluate the performance of a pre-trained model on PASCAL-Person-Part or CIHP val/test set, 
+simply run the script: `sh eval_cihp/pascal.sh`.
+Specify the specific model. And we provide the final model that you can download and store it in /data/pretrained_model/.
+
+### Models
+**Pascal-Person-Part trained model**
+
+|Model|Google Cloud|Baidu Yun|
+|--------|--------------|-----------|
+|Graphonomy(CIHP)| [Download](https://drive.google.com/file/d/1E_V_gVDWfAJFPfe-LLu2RQaYQMdhjv9h/view?usp=sharing)| Available soon|
+
+**CIHP trained model**
+
+|Model|Google Cloud|Baidu Yun|
+|--------|--------------|-----------|
+|Graphonomy(PASCAL)| [Download](https://drive.google.com/file/d/1eUe18HoH05p0yFUd_sN6GXdTj82aW0m9/view?usp=sharing)| Available soon|
+
+**Universal trained model**
+
+|Model|Google Cloud|Baidu Yun|
+|--------|--------------|-----------|
+|Universal| [Download](https://drive.google.com/file/d/1sWJ54lCBFnzCNz5RTCGQmkVovkY9x8_D/view?usp=sharing)|Available soon|
+
+### Todo:
+- [ ] release pretrained and trained models
+- [ ] update universal eval code&script
+
+# Citation
+
+```
+@inproceedings{Gong2019Graphonomy,
+author = {Ke Gong and Yiming Gao and Xiaodan Liang and Xiaohui Shen and Meng Wang and Liang Lin},
+title = {Graphonomy: Universal Human Parsing via Graph Transfer Learning},
+booktitle = {CVPR},
+year = {2019},
+}
+
+```
+
+# Contact
+if you have any questions about this repo, please feel free to contact 
+[[email protected]](mailto:[email protected]).
+
+##
+
+## Related work
++ Self-supervised Structure-sensitive Learning [SSL](https://github.com/Engineering-Course/LIP_SSL)
++ Joint Body Parsing & Pose Estimation Network  [JPPNet](https://github.com/Engineering-Course/LIP_JPPNet)
++ Instance-level Human Parsing via Part Grouping Network [PGN](https://github.com/Engineering-Course/CIHP_PGN)
++ Graphonomy: Universal Image Parsing via Graph Reasoning and Transfer [paper](https://arxiv.org/abs/2101.10620) [code](https://github.com/Gaoyiminggithub/Graphonomy-Panoptic)

TryYours-Virtual-Try-On/Graphonomy-master/dataloaders/atr.py

@@ -0,0 +1,109 @@
+from __future__ import print_function, division
+import os
+from PIL import Image
+from torch.utils.data import Dataset
+from .mypath_atr import Path
+import random
+from PIL import ImageFile
+ImageFile.LOAD_TRUNCATED_IMAGES = True
+
+class VOCSegmentation(Dataset):
+    """
+    ATR dataset
+    """
+
+    def __init__(self,
+                 base_dir=Path.db_root_dir('atr'),
+                 split='train',
+                 transform=None,
+                 flip=False,
+                 ):
+        """
+        :param base_dir: path to ATR dataset directory
+        :param split: train/val
+        :param transform: transform to apply
+        """
+        super(VOCSegmentation).__init__()
+        self._flip_flag = flip
+
+        self._base_dir = base_dir
+        self._image_dir = os.path.join(self._base_dir, 'JPEGImages')
+        self._cat_dir = os.path.join(self._base_dir, 'SegmentationClassAug')
+        self._flip_dir = os.path.join(self._base_dir,'SegmentationClassAug_rev')
+
+        if isinstance(split, str):
+            self.split = [split]
+        else:
+            split.sort()
+            self.split = split
+
+        self.transform = transform
+
+        _splits_dir = os.path.join(self._base_dir, 'list')
+
+        self.im_ids = []
+        self.images = []
+        self.categories = []
+        self.flip_categories = []
+
+        for splt in self.split:
+            with open(os.path.join(os.path.join(_splits_dir, splt + '_id.txt')), "r") as f:
+                lines = f.read().splitlines()
+
+            for ii, line in enumerate(lines):
+
+                _image = os.path.join(self._image_dir, line+'.jpg' )
+                _cat = os.path.join(self._cat_dir, line +'.png')
+                _flip = os.path.join(self._flip_dir,line + '.png')
+                # print(self._image_dir,_image)
+                assert os.path.isfile(_image)
+                # print(_cat)
+                assert os.path.isfile(_cat)
+                assert os.path.isfile(_flip)
+                self.im_ids.append(line)
+                self.images.append(_image)
+                self.categories.append(_cat)
+                self.flip_categories.append(_flip)
+
+
+        assert (len(self.images) == len(self.categories))
+        assert len(self.flip_categories) == len(self.categories)
+
+        # Display stats
+        print('Number of images in {}: {:d}'.format(split, len(self.images)))
+
+    def __len__(self):
+        return len(self.images)
+
+
+    def __getitem__(self, index):
+        _img, _target= self._make_img_gt_point_pair(index)
+        sample = {'image': _img, 'label': _target}
+
+        if self.transform is not None:
+            sample = self.transform(sample)
+
+        return sample
+
+    def _make_img_gt_point_pair(self, index):
+        # Read Image and Target
+        # _img = np.array(Image.open(self.images[index]).convert('RGB')).astype(np.float32)
+        # _target = np.array(Image.open(self.categories[index])).astype(np.float32)
+
+        _img = Image.open(self.images[index]).convert('RGB')  # return is RGB pic
+        if self._flip_flag:
+            if random.random() < 0.5:
+                _target = Image.open(self.flip_categories[index])
+                _img = _img.transpose(Image.FLIP_LEFT_RIGHT)
+            else:
+                _target = Image.open(self.categories[index])
+        else:
+            _target = Image.open(self.categories[index])
+
+        return _img, _target
+
+    def __str__(self):
+        return 'ATR(split=' + str(self.split) + ')'
+
+
+

TryYours-Virtual-Try-On/Graphonomy-master/dataloaders/cihp.py

@@ -0,0 +1,107 @@
+from __future__ import print_function, division
+import os
+from PIL import Image
+from torch.utils.data import Dataset
+from .mypath_cihp import Path
+import random
+
+class VOCSegmentation(Dataset):
+    """
+    CIHP dataset
+    """
+
+    def __init__(self,
+                 base_dir=Path.db_root_dir('cihp'),
+                 split='train',
+                 transform=None,
+                 flip=False,
+                 ):
+        """
+        :param base_dir: path to CIHP dataset directory
+        :param split: train/val/test
+        :param transform: transform to apply
+        """
+        super(VOCSegmentation).__init__()
+        self._flip_flag = flip
+
+        self._base_dir = base_dir
+        self._image_dir = os.path.join(self._base_dir, 'Images')
+        self._cat_dir = os.path.join(self._base_dir, 'Category_ids')
+        self._flip_dir = os.path.join(self._base_dir,'Category_rev_ids')
+
+        if isinstance(split, str):
+            self.split = [split]
+        else:
+            split.sort()
+            self.split = split
+
+        self.transform = transform
+
+        _splits_dir = os.path.join(self._base_dir, 'lists')
+
+        self.im_ids = []
+        self.images = []
+        self.categories = []
+        self.flip_categories = []
+
+        for splt in self.split:
+            with open(os.path.join(os.path.join(_splits_dir, splt + '_id.txt')), "r") as f:
+                lines = f.read().splitlines()
+
+            for ii, line in enumerate(lines):
+
+                _image = os.path.join(self._image_dir, line+'.jpg' )
+                _cat = os.path.join(self._cat_dir, line +'.png')
+                _flip = os.path.join(self._flip_dir,line + '.png')
+                # print(self._image_dir,_image)
+                assert os.path.isfile(_image)
+                # print(_cat)
+                assert os.path.isfile(_cat)
+                assert os.path.isfile(_flip)
+                self.im_ids.append(line)
+                self.images.append(_image)
+                self.categories.append(_cat)
+                self.flip_categories.append(_flip)
+
+
+        assert (len(self.images) == len(self.categories))
+        assert len(self.flip_categories) == len(self.categories)
+
+        # Display stats
+        print('Number of images in {}: {:d}'.format(split, len(self.images)))
+
+    def __len__(self):
+        return len(self.images)
+
+
+    def __getitem__(self, index):
+        _img, _target= self._make_img_gt_point_pair(index)
+        sample = {'image': _img, 'label': _target}
+
+        if self.transform is not None:
+            sample = self.transform(sample)
+
+        return sample
+
+    def _make_img_gt_point_pair(self, index):
+        # Read Image and Target
+        # _img = np.array(Image.open(self.images[index]).convert('RGB')).astype(np.float32)
+        # _target = np.array(Image.open(self.categories[index])).astype(np.float32)
+
+        _img = Image.open(self.images[index]).convert('RGB')  # return is RGB pic
+        if self._flip_flag:
+            if random.random() < 0.5:
+                _target = Image.open(self.flip_categories[index])
+                _img = _img.transpose(Image.FLIP_LEFT_RIGHT)
+            else:
+                _target = Image.open(self.categories[index])
+        else:
+            _target = Image.open(self.categories[index])
+
+        return _img, _target
+
+    def __str__(self):
+        return 'CIHP(split=' + str(self.split) + ')'
+
+
+

TryYours-Virtual-Try-On/Graphonomy-master/dataloaders/cihp_pascal_atr.py

@@ -0,0 +1,219 @@
+from __future__ import print_function, division
+import os
+from PIL import Image
+import numpy as np
+from torch.utils.data import Dataset
+from .mypath_cihp import Path
+from .mypath_pascal import Path as PP
+from .mypath_atr import Path as PA
+import random
+from PIL import ImageFile
+ImageFile.LOAD_TRUNCATED_IMAGES = True
+
+class VOCSegmentation(Dataset):
+    """
+    Pascal dataset
+    """
+
+    def __init__(self,
+                 cihp_dir=Path.db_root_dir('cihp'),
+                 split='train',
+                 transform=None,
+                 flip=False,
+                 pascal_dir = PP.db_root_dir('pascal'),
+                 atr_dir = PA.db_root_dir('atr'),
+                 ):
+        """
+        :param cihp_dir: path to CIHP dataset directory
+        :param pascal_dir: path to PASCAL dataset directory
+        :param atr_dir: path to ATR dataset directory
+        :param split: train/val
+        :param transform: transform to apply
+        """
+        super(VOCSegmentation).__init__()
+        ## for cihp
+        self._flip_flag = flip
+        self._base_dir = cihp_dir
+        self._image_dir = os.path.join(self._base_dir, 'Images')
+        self._cat_dir = os.path.join(self._base_dir, 'Category_ids')
+        self._flip_dir = os.path.join(self._base_dir,'Category_rev_ids')
+        ## for Pascal
+        self._base_dir_pascal = pascal_dir
+        self._image_dir_pascal = os.path.join(self._base_dir_pascal, 'JPEGImages')
+        self._cat_dir_pascal = os.path.join(self._base_dir_pascal, 'SegmentationPart')
+        # self._flip_dir_pascal = os.path.join(self._base_dir_pascal, 'Category_rev_ids')
+        ## for atr
+        self._base_dir_atr = atr_dir
+        self._image_dir_atr = os.path.join(self._base_dir_atr, 'JPEGImages')
+        self._cat_dir_atr = os.path.join(self._base_dir_atr, 'SegmentationClassAug')
+        self._flip_dir_atr = os.path.join(self._base_dir_atr, 'SegmentationClassAug_rev')
+
+        if isinstance(split, str):
+            self.split = [split]
+        else:
+            split.sort()
+            self.split = split
+
+        self.transform = transform
+
+        _splits_dir = os.path.join(self._base_dir, 'lists')
+        _splits_dir_pascal = os.path.join(self._base_dir_pascal, 'list')
+        _splits_dir_atr = os.path.join(self._base_dir_atr, 'list')
+
+        self.im_ids = []
+        self.images = []
+        self.categories = []
+        self.flip_categories = []
+        self.datasets_lbl = []
+
+        # num
+        self.num_cihp = 0
+        self.num_pascal = 0
+        self.num_atr = 0
+        # for cihp is 0
+        for splt in self.split:
+            with open(os.path.join(os.path.join(_splits_dir, splt + '_id.txt')), "r") as f:
+                lines = f.read().splitlines()
+            self.num_cihp += len(lines)
+            for ii, line in enumerate(lines):
+
+                _image = os.path.join(self._image_dir, line+'.jpg' )
+                _cat = os.path.join(self._cat_dir, line +'.png')
+                _flip = os.path.join(self._flip_dir,line + '.png')
+                # print(self._image_dir,_image)
+                assert os.path.isfile(_image)
+                # print(_cat)
+                assert os.path.isfile(_cat)
+                assert os.path.isfile(_flip)
+                self.im_ids.append(line)
+                self.images.append(_image)
+                self.categories.append(_cat)
+                self.flip_categories.append(_flip)
+                self.datasets_lbl.append(0)
+
+        # for pascal is 1
+        for splt in self.split:
+            if splt == 'test':
+                splt='val'
+            with open(os.path.join(os.path.join(_splits_dir_pascal, splt + '_id.txt')), "r") as f:
+                lines = f.read().splitlines()
+            self.num_pascal += len(lines)
+            for ii, line in enumerate(lines):
+
+                _image = os.path.join(self._image_dir_pascal, line+'.jpg' )
+                _cat = os.path.join(self._cat_dir_pascal, line +'.png')
+                # _flip = os.path.join(self._flip_dir,line + '.png')
+                # print(self._image_dir,_image)
+                assert os.path.isfile(_image)
+                # print(_cat)
+                assert os.path.isfile(_cat)
+                # assert os.path.isfile(_flip)
+                self.im_ids.append(line)
+                self.images.append(_image)
+                self.categories.append(_cat)
+                self.flip_categories.append([])
+                self.datasets_lbl.append(1)
+
+        # for atr is 2
+        for splt in self.split:
+            with open(os.path.join(os.path.join(_splits_dir_atr, splt + '_id.txt')), "r") as f:
+                lines = f.read().splitlines()
+            self.num_atr += len(lines)
+            for ii, line in enumerate(lines):
+                _image = os.path.join(self._image_dir_atr, line + '.jpg')
+                _cat = os.path.join(self._cat_dir_atr, line + '.png')
+                _flip = os.path.join(self._flip_dir_atr, line + '.png')
+                # print(self._image_dir,_image)
+                assert os.path.isfile(_image)
+                # print(_cat)
+                assert os.path.isfile(_cat)
+                assert os.path.isfile(_flip)
+                self.im_ids.append(line)
+                self.images.append(_image)
+                self.categories.append(_cat)
+                self.flip_categories.append(_flip)
+                self.datasets_lbl.append(2)
+
+        assert (len(self.images) == len(self.categories))
+        # assert len(self.flip_categories) == len(self.categories)
+
+        # Display stats
+        print('Number of images in {}: {:d}'.format(split, len(self.images)))
+
+    def __len__(self):
+        return len(self.images)
+
+    def get_class_num(self):
+        return self.num_cihp,self.num_pascal,self.num_atr
+
+
+
+    def __getitem__(self, index):
+        _img, _target,_lbl= self._make_img_gt_point_pair(index)
+        sample = {'image': _img, 'label': _target,}
+
+        if self.transform is not None:
+            sample = self.transform(sample)
+        sample['pascal'] = _lbl
+        return sample
+
+    def _make_img_gt_point_pair(self, index):
+        # Read Image and Target
+        # _img = np.array(Image.open(self.images[index]).convert('RGB')).astype(np.float32)
+        # _target = np.array(Image.open(self.categories[index])).astype(np.float32)
+
+        _img = Image.open(self.images[index]).convert('RGB')  # return is RGB pic
+        type_lbl = self.datasets_lbl[index]
+        if self._flip_flag:
+            if random.random() < 0.5 :
+                # _target = Image.open(self.flip_categories[index])
+                _img = _img.transpose(Image.FLIP_LEFT_RIGHT)
+                if type_lbl == 0 or type_lbl == 2:
+                    _target = Image.open(self.flip_categories[index])
+                else:
+                    _target = Image.open(self.categories[index])
+                    _target = _target.transpose(Image.FLIP_LEFT_RIGHT)
+            else:
+                _target = Image.open(self.categories[index])
+        else:
+            _target = Image.open(self.categories[index])
+
+        return _img, _target,type_lbl
+
+    def __str__(self):
+        return 'datasets(split=' + str(self.split) + ')'
+
+
+
+
+
+
+
+
+
+
+
+
+if __name__ == '__main__':
+    from dataloaders import custom_transforms as tr
+    from dataloaders.utils import decode_segmap
+    from torch.utils.data import DataLoader
+    from torchvision import transforms
+    import matplotlib.pyplot as plt
+
+    composed_transforms_tr = transforms.Compose([
+        # tr.RandomHorizontalFlip(),
+        tr.RandomSized_new(512),
+        tr.RandomRotate(15),
+        tr.ToTensor_()])
+
+
+
+    voc_train = VOCSegmentation(split='train',
+                                transform=composed_transforms_tr)
+
+    dataloader = DataLoader(voc_train, batch_size=5, shuffle=True, num_workers=1)
+
+    for ii, sample in enumerate(dataloader):
+        if ii >10:
+            break

TryYours-Virtual-Try-On/Graphonomy-master/dataloaders/custom_transforms.py

@@ -0,0 +1,491 @@
+import torch
+import math
+import numbers
+import random
+import numpy as np
+
+from PIL import Image, ImageOps
+from torchvision import transforms
+
+class RandomCrop(object):
+    def __init__(self, size, padding=0):
+        if isinstance(size, numbers.Number):
+            self.size = (int(size), int(size))
+        else:
+            self.size = size # h, w
+        self.padding = padding
+
+    def __call__(self, sample):
+        img, mask = sample['image'], sample['label']
+
+        if self.padding > 0:
+            img = ImageOps.expand(img, border=self.padding, fill=0)
+            mask = ImageOps.expand(mask, border=self.padding, fill=0)
+
+        assert img.size == mask.size
+        w, h = img.size
+        th, tw = self.size # target size
+        if w == tw and h == th:
+            return {'image': img,
+                    'label': mask}
+        if w < tw or h < th:
+            img = img.resize((tw, th), Image.BILINEAR)
+            mask = mask.resize((tw, th), Image.NEAREST)
+            return {'image': img,
+                    'label': mask}
+
+        x1 = random.randint(0, w - tw)
+        y1 = random.randint(0, h - th)
+        img = img.crop((x1, y1, x1 + tw, y1 + th))
+        mask = mask.crop((x1, y1, x1 + tw, y1 + th))
+
+        return {'image': img,
+                'label': mask}
+
+class RandomCrop_new(object):
+    def __init__(self, size, padding=0):
+        if isinstance(size, numbers.Number):
+            self.size = (int(size), int(size))
+        else:
+            self.size = size # h, w
+        self.padding = padding
+
+    def __call__(self, sample):
+        img, mask = sample['image'], sample['label']
+
+        if self.padding > 0:
+            img = ImageOps.expand(img, border=self.padding, fill=0)
+            mask = ImageOps.expand(mask, border=self.padding, fill=0)
+
+        assert img.size == mask.size
+        w, h = img.size
+        th, tw = self.size # target size
+        if w == tw and h == th:
+            return {'image': img,
+                    'label': mask}
+
+        new_img = Image.new('RGB',(tw,th),'black')  # size is w x h; and 'white' is 255
+        new_mask = Image.new('L',(tw,th),'white')  # same above
+
+        # if w > tw or h > th
+        x1 = y1 = 0
+        if w > tw:
+            x1 = random.randint(0,w - tw)
+        if h > th:
+            y1 = random.randint(0,h - th)
+        # crop
+        img = img.crop((x1,y1, x1 + tw, y1 + th))
+        mask = mask.crop((x1,y1, x1 + tw, y1 + th))
+        new_img.paste(img,(0,0))
+        new_mask.paste(mask,(0,0))
+
+        # x1 = random.randint(0, w - tw)
+        # y1 = random.randint(0, h - th)
+        # img = img.crop((x1, y1, x1 + tw, y1 + th))
+        # mask = mask.crop((x1, y1, x1 + tw, y1 + th))
+
+        return {'image': new_img,
+                'label': new_mask}
+
+class Paste(object):
+    def __init__(self, size,):
+        if isinstance(size, numbers.Number):
+            self.size = (int(size), int(size))
+        else:
+            self.size = size # h, w
+
+    def __call__(self, sample):
+        img, mask = sample['image'], sample['label']
+
+        assert img.size == mask.size
+        w, h = img.size
+        th, tw = self.size # target size
+        assert (w <=tw) and (h <= th)
+        if w == tw and h == th:
+            return {'image': img,
+                    'label': mask}
+
+        new_img = Image.new('RGB',(tw,th),'black')  # size is w x h; and 'white' is 255
+        new_mask = Image.new('L',(tw,th),'white')  # same above
+
+        new_img.paste(img,(0,0))
+        new_mask.paste(mask,(0,0))
+
+        return {'image': new_img,
+                'label': new_mask}
+
+class CenterCrop(object):
+    def __init__(self, size):
+        if isinstance(size, numbers.Number):
+            self.size = (int(size), int(size))
+        else:
+            self.size = size
+
+    def __call__(self, sample):
+        img = sample['image']
+        mask = sample['label']
+        assert img.size == mask.size
+        w, h = img.size
+        th, tw = self.size
+        x1 = int(round((w - tw) / 2.))
+        y1 = int(round((h - th) / 2.))
+        img = img.crop((x1, y1, x1 + tw, y1 + th))
+        mask = mask.crop((x1, y1, x1 + tw, y1 + th))
+
+        return {'image': img,
+                'label': mask}
+
+class RandomHorizontalFlip(object):
+    def __call__(self, sample):
+        img = sample['image']
+        mask = sample['label']
+        if random.random() < 0.5:
+            img = img.transpose(Image.FLIP_LEFT_RIGHT)
+            mask = mask.transpose(Image.FLIP_LEFT_RIGHT)
+
+        return {'image': img,
+                'label': mask}
+
+class HorizontalFlip(object):
+    def __call__(self, sample):
+        img = sample['image']
+        mask = sample['label']
+        img = img.transpose(Image.FLIP_LEFT_RIGHT)
+        mask = mask.transpose(Image.FLIP_LEFT_RIGHT)
+
+        return {'image': img,
+                'label': mask}
+
+class HorizontalFlip_only_img(object):
+    def __call__(self, sample):
+        img = sample['image']
+        mask = sample['label']
+        img = img.transpose(Image.FLIP_LEFT_RIGHT)
+        # mask = mask.transpose(Image.FLIP_LEFT_RIGHT)
+
+        return {'image': img,
+                'label': mask}
+
+class RandomHorizontalFlip_cihp(object):
+    def __call__(self, sample):
+        img = sample['image']
+        mask = sample['label']
+        if random.random() < 0.5:
+            img = img.transpose(Image.FLIP_LEFT_RIGHT)
+            # mask = Image.open()
+
+        return {'image': img,
+                'label': mask}
+
+class Normalize(object):
+    """Normalize a tensor image with mean and standard deviation.
+    Args:
+        mean (tuple): means for each channel.
+        std (tuple): standard deviations for each channel.
+    """
+    def __init__(self, mean=(0., 0., 0.), std=(1., 1., 1.)):
+        self.mean = mean
+        self.std = std
+
+    def __call__(self, sample):
+        img = np.array(sample['image']).astype(np.float32)
+        mask = np.array(sample['label']).astype(np.float32)
+        img /= 255.0
+        img -= self.mean
+        img /= self.std
+
+        return {'image': img,
+                'label': mask}
+
+class Normalize_255(object):
+    """Normalize a tensor image with mean and standard deviation. tf use 255.
+    Args:
+        mean (tuple): means for each channel.
+        std (tuple): standard deviations for each channel.
+    """
+    def __init__(self, mean=(123.15, 115.90, 103.06), std=(1., 1., 1.)):
+        self.mean = mean
+        self.std = std
+
+    def __call__(self, sample):
+        img = np.array(sample['image']).astype(np.float32)
+        mask = np.array(sample['label']).astype(np.float32)
+        # img = 255.0
+        img -= self.mean
+        img /= self.std
+        img = img
+        img = img[[0,3,2,1],...]
+        return {'image': img,
+                'label': mask}
+
+class Normalize_xception_tf(object):
+    # def __init__(self):
+    #     self.rgb2bgr =
+
+    def __call__(self, sample):
+        img = np.array(sample['image']).astype(np.float32)
+        mask = np.array(sample['label']).astype(np.float32)
+        img = (img*2.0)/255.0 - 1
+        # print(img.shape)
+        # img = img[[0,3,2,1],...]
+        return {'image': img,
+                'label': mask}
+
+class Normalize_xception_tf_only_img(object):
+    # def __init__(self):
+    #     self.rgb2bgr =
+
+    def __call__(self, sample):
+        img = np.array(sample['image']).astype(np.float32)
+        # mask = np.array(sample['label']).astype(np.float32)
+        img = (img*2.0)/255.0 - 1
+        # print(img.shape)
+        # img = img[[0,3,2,1],...]
+        return {'image': img,
+                'label': sample['label']}
+
+class Normalize_cityscapes(object):
+    """Normalize a tensor image with mean and standard deviation.
+    Args:
+        mean (tuple): means for each channel.
+        std (tuple): standard deviations for each channel.
+    """
+    def __init__(self, mean=(0., 0., 0.)):
+        self.mean = mean
+
+    def __call__(self, sample):
+        img = np.array(sample['image']).astype(np.float32)
+        mask = np.array(sample['label']).astype(np.float32)
+        img -= self.mean
+        img /= 255.0
+
+        return {'image': img,
+                'label': mask}
+
+class ToTensor_(object):
+    """Convert ndarrays in sample to Tensors."""
+    def __init__(self):
+        self.rgb2bgr = transforms.Lambda(lambda x:x[[2,1,0],...])
+
+    def __call__(self, sample):
+        # swap color axis because
+        # numpy image: H x W x C
+        # torch image: C X H X W
+        img = np.array(sample['image']).astype(np.float32).transpose((2, 0, 1))
+        mask = np.expand_dims(np.array(sample['label']).astype(np.float32), -1).transpose((2, 0, 1))
+        # mask[mask == 255] = 0
+
+        img = torch.from_numpy(img).float()
+        img = self.rgb2bgr(img)
+        mask = torch.from_numpy(mask).float()
+
+
+        return {'image': img,
+                'label': mask}
+
+class ToTensor_only_img(object):
+    """Convert ndarrays in sample to Tensors."""
+    def __init__(self):
+        self.rgb2bgr = transforms.Lambda(lambda x:x[[2,1,0],...])
+
+    def __call__(self, sample):
+        # swap color axis because
+        # numpy image: H x W x C
+        # torch image: C X H X W
+        img = np.array(sample['image']).astype(np.float32).transpose((2, 0, 1))
+        # mask = np.expand_dims(np.array(sample['label']).astype(np.float32), -1).transpose((2, 0, 1))
+        # mask[mask == 255] = 0
+
+        img = torch.from_numpy(img).float()
+        img = self.rgb2bgr(img)
+        # mask = torch.from_numpy(mask).float()
+
+
+        return {'image': img,
+                'label': sample['label']}
+
+class FixedResize(object):
+    def __init__(self, size):
+        self.size = tuple(reversed(size))  # size: (h, w)
+
+    def __call__(self, sample):
+        img = sample['image']
+        mask = sample['label']
+
+        assert img.size == mask.size
+
+        img = img.resize(self.size, Image.BILINEAR)
+        mask = mask.resize(self.size, Image.NEAREST)
+
+        return {'image': img,
+                'label': mask}
+
+class Keep_origin_size_Resize(object):
+    def __init__(self, max_size, scale=1.0):
+        self.size = tuple(reversed(max_size))  # size: (h, w)
+        self.scale = scale
+        self.paste = Paste(int(max_size[0]*scale))
+
+    def __call__(self, sample):
+        img = sample['image']
+        mask = sample['label']
+
+        assert img.size == mask.size
+        h, w = self.size
+        h = int(h*self.scale)
+        w = int(w*self.scale)
+        img = img.resize((h, w), Image.BILINEAR)
+        mask = mask.resize((h, w), Image.NEAREST)
+
+        return self.paste({'image': img,
+                'label': mask})
+
+class Scale(object):
+    def __init__(self, size):
+        if isinstance(size, numbers.Number):
+            self.size = (int(size), int(size))
+        else:
+            self.size = size
+
+    def __call__(self, sample):
+        img = sample['image']
+        mask = sample['label']
+        assert img.size == mask.size
+        w, h = img.size
+
+        if (w >= h and w == self.size[1]) or (h >= w and h == self.size[0]):
+            return {'image': img,
+                    'label': mask}
+        oh, ow = self.size
+        img = img.resize((ow, oh), Image.BILINEAR)
+        mask = mask.resize((ow, oh), Image.NEAREST)
+
+        return {'image': img,
+                'label': mask}
+
+class Scale_(object):
+    def __init__(self, scale):
+        self.scale = scale
+
+    def __call__(self, sample):
+        img = sample['image']
+        mask = sample['label']
+        assert img.size == mask.size
+        w, h = img.size
+        ow = int(w*self.scale)
+        oh = int(h*self.scale)
+        img = img.resize((ow, oh), Image.BILINEAR)
+        mask = mask.resize((ow, oh), Image.NEAREST)
+
+        return {'image': img,
+                'label': mask}
+
+class Scale_only_img(object):
+    def __init__(self, scale):
+        self.scale = scale
+
+    def __call__(self, sample):
+        img = sample['image']
+        mask = sample['label']
+        # assert img.size == mask.size
+        w, h = img.size
+        ow = int(w*self.scale)
+        oh = int(h*self.scale)
+        img = img.resize((ow, oh), Image.BILINEAR)
+        # mask = mask.resize((ow, oh), Image.NEAREST)
+
+        return {'image': img,
+                'label': mask}
+
+class RandomSizedCrop(object):
+    def __init__(self, size):
+        self.size = size
+
+    def __call__(self, sample):
+        img = sample['image']
+        mask = sample['label']
+        assert img.size == mask.size
+        for attempt in range(10):
+            area = img.size[0] * img.size[1]
+            target_area = random.uniform(0.45, 1.0) * area
+            aspect_ratio = random.uniform(0.5, 2)
+
+            w = int(round(math.sqrt(target_area * aspect_ratio)))
+            h = int(round(math.sqrt(target_area / aspect_ratio)))
+
+            if random.random() < 0.5:
+                w, h = h, w
+
+            if w <= img.size[0] and h <= img.size[1]:
+                x1 = random.randint(0, img.size[0] - w)
+                y1 = random.randint(0, img.size[1] - h)
+
+                img = img.crop((x1, y1, x1 + w, y1 + h))
+                mask = mask.crop((x1, y1, x1 + w, y1 + h))
+                assert (img.size == (w, h))
+
+                img = img.resize((self.size, self.size), Image.BILINEAR)
+                mask = mask.resize((self.size, self.size), Image.NEAREST)
+
+                return {'image': img,
+                        'label': mask}
+
+        # Fallback
+        scale = Scale(self.size)
+        crop = CenterCrop(self.size)
+        sample = crop(scale(sample))
+        return sample
+
+class RandomRotate(object):
+    def __init__(self, degree):
+        self.degree = degree
+
+    def __call__(self, sample):
+        img = sample['image']
+        mask = sample['label']
+        rotate_degree = random.random() * 2 * self.degree - self.degree
+        img = img.rotate(rotate_degree, Image.BILINEAR)
+        mask = mask.rotate(rotate_degree, Image.NEAREST)
+
+        return {'image': img,
+                'label': mask}
+
+class RandomSized_new(object):
+    '''what we use is this class to aug'''
+    def __init__(self, size,scale1=0.5,scale2=2):
+        self.size = size
+        # self.scale = Scale(self.size)
+        self.crop = RandomCrop_new(self.size)
+        self.small_scale = scale1
+        self.big_scale = scale2
+
+    def __call__(self, sample):
+        img = sample['image']
+        mask = sample['label']
+        assert img.size == mask.size
+
+        w = int(random.uniform(self.small_scale, self.big_scale) * img.size[0])
+        h = int(random.uniform(self.small_scale, self.big_scale) * img.size[1])
+
+        img, mask = img.resize((w, h), Image.BILINEAR), mask.resize((w, h), Image.NEAREST)
+        sample = {'image': img, 'label': mask}
+        # finish resize
+        return self.crop(sample)
+# class Random
+
+class RandomScale(object):
+    def __init__(self, limit):
+        self.limit = limit
+
+    def __call__(self, sample):
+        img = sample['image']
+        mask = sample['label']
+        assert img.size == mask.size
+
+        scale = random.uniform(self.limit[0], self.limit[1])
+        w = int(scale * img.size[0])
+        h = int(scale * img.size[1])
+
+        img, mask = img.resize((w, h), Image.BILINEAR), mask.resize((w, h), Image.NEAREST)
+
+        return {'image': img, 'label': mask}

TryYours-Virtual-Try-On/Graphonomy-master/dataloaders/mypath_atr.py

@@ -0,0 +1,8 @@
+class Path(object):
+    @staticmethod
+    def db_root_dir(database):
+        if database == 'atr':
+            return './data/datasets/ATR/'  # folder that contains atr/.
+        else:
+            print('Database {} not available.'.format(database))
+            raise NotImplementedError

TryYours-Virtual-Try-On/Graphonomy-master/dataloaders/mypath_cihp.py

@@ -0,0 +1,8 @@
+class Path(object):
+    @staticmethod
+    def db_root_dir(database):
+        if database == 'cihp':
+            return './data/datasets/CIHP_4w/'
+        else:
+            print('Database {} not available.'.format(database))
+            raise NotImplementedError

TryYours-Virtual-Try-On/Graphonomy-master/dataloaders/mypath_pascal.py

@@ -0,0 +1,8 @@
+class Path(object):
+    @staticmethod
+    def db_root_dir(database):
+        if database == 'pascal':
+            return './data/datasets/pascal/'  # folder that contains pascal/.
+        else:
+            print('Database {} not available.'.format(database))
+            raise NotImplementedError

TryYours-Virtual-Try-On/Graphonomy-master/dataloaders/pascal.py

@@ -0,0 +1,106 @@
+from __future__ import print_function, division
+import os
+from PIL import Image
+from torch.utils.data import Dataset
+from .mypath_pascal import Path
+
+class VOCSegmentation(Dataset):
+    """
+    Pascal dataset
+    """
+
+    def __init__(self,
+                 base_dir=Path.db_root_dir('pascal'),
+                 split='train',
+                 transform=None
+                 ):
+        """
+        :param base_dir: path to PASCAL dataset directory
+        :param split: train/val
+        :param transform: transform to apply
+        """
+        super(VOCSegmentation).__init__()
+        self._base_dir = base_dir
+        self._image_dir = os.path.join(self._base_dir, 'JPEGImages')
+        self._cat_dir = os.path.join(self._base_dir, 'SegmentationPart')
+
+        if isinstance(split, str):
+            self.split = [split]
+        else:
+            split.sort()
+            self.split = split
+
+        self.transform = transform
+
+        _splits_dir = os.path.join(self._base_dir, 'list')
+
+        self.im_ids = []
+        self.images = []
+        self.categories = []
+
+        for splt in self.split:
+            with open(os.path.join(os.path.join(_splits_dir, splt + '_id.txt')), "r") as f:
+                lines = f.read().splitlines()
+
+            for ii, line in enumerate(lines):
+
+                _image = os.path.join(self._image_dir, line+'.jpg' )
+                _cat = os.path.join(self._cat_dir, line +'.png')
+                # print(self._image_dir,_image)
+                assert os.path.isfile(_image)
+                # print(_cat)
+                assert os.path.isfile(_cat)
+                self.im_ids.append(line)
+                self.images.append(_image)
+                self.categories.append(_cat)
+
+        assert (len(self.images) == len(self.categories))
+
+        # Display stats
+        print('Number of images in {}: {:d}'.format(split, len(self.images)))
+
+    def __len__(self):
+        return len(self.images)
+
+
+    def __getitem__(self, index):
+        _img, _target= self._make_img_gt_point_pair(index)
+        sample = {'image': _img, 'label': _target}
+
+        if self.transform is not None:
+            sample = self.transform(sample)
+
+        return sample
+
+    def _make_img_gt_point_pair(self, index):
+        # Read Image and Target
+        # _img = np.array(Image.open(self.images[index]).convert('RGB')).astype(np.float32)
+        # _target = np.array(Image.open(self.categories[index])).astype(np.float32)
+
+        _img = Image.open(self.images[index]).convert('RGB') # return is RGB pic
+        _target = Image.open(self.categories[index])
+
+        return _img, _target
+
+    def __str__(self):
+        return 'PASCAL(split=' + str(self.split) + ')'
+
+class test_segmentation(VOCSegmentation):
+    def __init__(self,base_dir=Path.db_root_dir('pascal'),
+                 split='train',
+                 transform=None,
+                 flip=True):
+        super(test_segmentation, self).__init__(base_dir=base_dir,split=split,transform=transform)
+        self._flip_flag = flip
+
+    def __getitem__(self, index):
+        _img, _target= self._make_img_gt_point_pair(index)
+        sample = {'image': _img, 'label': _target}
+
+        if self.transform is not None:
+            sample = self.transform(sample)
+
+        return sample
+
+
+

TryYours-Virtual-Try-On/Graphonomy-master/eval_cihp.sh

@@ -0,0 +1,5 @@
+python ./exp/test/eval_show_pascal2cihp.py \
+ --batch 1 --gpus 1 --classes 20 \
+ --gt_path './data/datasets/CIHP_4w/Category_ids' \
+ --txt_file './data/datasets/CIHP_4w/lists/val_id.txt' \
+ --loadmodel './data/pretrained_model/inference.pth'

TryYours-Virtual-Try-On/Graphonomy-master/eval_pascal.sh

@@ -0,0 +1,5 @@
+python ./exp/test/eval_show_pascal.py \
+ --batch 1 --gpus 1 --classes 7 \
+ --gt_path './data/datasets/pascal/SegmentationPart/' \
+ --txt_file './data/datasets/pascal/list/val_id.txt' \
+ --loadmodel './cihp2pascal.pth'

TryYours-Virtual-Try-On/Graphonomy-master/exp/inference/.ipynb_checkpoints/inference-checkpoint.py

@@ -0,0 +1,203 @@
+import socket
+import timeit
+import numpy as np
+from PIL import Image
+from datetime import datetime
+import os
+import sys
+from collections import OrderedDict
+sys.path.append('./')
+# PyTorch includes
+import torch
+from torch.autograd import Variable
+from torchvision import transforms
+import cv2
+
+
+# Custom includes
+from networks import deeplab_xception_transfer, graph
+from dataloaders import custom_transforms as tr
+
+#
+import argparse
+import torch.nn.functional as F
+
+label_colours = [(0,0,0)
+                , (128,0,0), (255,0,0), (0,85,0), (170,0,51), (255,85,0), (0,0,85), (0,119,221), (85,85,0), (0,85,85), (85,51,0), (52,86,128), (0,128,0)
+                , (0,0,255), (51,170,221), (0,255,255), (85,255,170), (170,255,85), (255,255,0), (255,170,0)]
+
+
+def flip(x, dim):
+    indices = [slice(None)] * x.dim()
+    indices[dim] = torch.arange(x.size(dim) - 1, -1, -1,
+                                dtype=torch.long, device=x.device)
+    return x[tuple(indices)]
+
+def flip_cihp(tail_list):
+    '''
+
+    :param tail_list: tail_list size is 1 x n_class x h x w
+    :return:
+    '''
+    # tail_list = tail_list[0]
+    tail_list_rev = [None] * 20
+    for xx in range(14):
+        tail_list_rev[xx] = tail_list[xx].unsqueeze(0)
+    tail_list_rev[14] = tail_list[15].unsqueeze(0)
+    tail_list_rev[15] = tail_list[14].unsqueeze(0)
+    tail_list_rev[16] = tail_list[17].unsqueeze(0)
+    tail_list_rev[17] = tail_list[16].unsqueeze(0)
+    tail_list_rev[18] = tail_list[19].unsqueeze(0)
+    tail_list_rev[19] = tail_list[18].unsqueeze(0)
+    return torch.cat(tail_list_rev,dim=0)
+
+
+def decode_labels(mask, num_images=1, num_classes=20):
+    """Decode batch of segmentation masks.
+
+    Args:
+      mask: result of inference after taking argmax.
+      num_images: number of images to decode from the batch.
+      num_classes: number of classes to predict (including background).
+
+    Returns:
+      A batch with num_images RGB images of the same size as the input.
+    """
+    n, h, w = mask.shape
+    assert (n >= num_images), 'Batch size %d should be greater or equal than number of images to save %d.' % (
+    n, num_images)
+    outputs = np.zeros((num_images, h, w, 3), dtype=np.uint8)
+    for i in range(num_images):
+        img = Image.new('RGB', (len(mask[i, 0]), len(mask[i])))
+        pixels = img.load()
+        for j_, j in enumerate(mask[i, :, :]):
+            for k_, k in enumerate(j):
+                if k < num_classes:
+                    pixels[k_, j_] = label_colours[k]
+        outputs[i] = np.array(img)
+    return outputs
+
+def read_img(img_path):
+    _img = Image.open(img_path).convert('RGB')  # return is RGB pic
+    return _img
+
+def img_transform(img, transform=None):
+    sample = {'image': img, 'label': 0}
+
+    sample = transform(sample)
+    return sample
+
+def inference(net, img_path='', output_path='./', output_name='f', use_gpu=True):
+    '''
+
+    :param net:
+    :param img_path:
+    :param output_path:
+    :return:
+    '''
+    # adj
+    adj2_ = torch.from_numpy(graph.cihp2pascal_nlp_adj).float()
+    adj2_test = adj2_.unsqueeze(0).unsqueeze(0).expand(1, 1, 7, 20).cuda().transpose(2, 3)
+
+    adj1_ = Variable(torch.from_numpy(graph.preprocess_adj(graph.pascal_graph)).float())
+    adj3_test = adj1_.unsqueeze(0).unsqueeze(0).expand(1, 1, 7, 7).cuda()
+
+    cihp_adj = graph.preprocess_adj(graph.cihp_graph)
+    adj3_ = Variable(torch.from_numpy(cihp_adj).float())
+    adj1_test = adj3_.unsqueeze(0).unsqueeze(0).expand(1, 1, 20, 20).cuda()
+
+    # multi-scale
+    scale_list = [1, 0.5, 0.75, 1.25, 1.5, 1.75]
+    img = read_img(img_path)
+    testloader_list = []
+    testloader_flip_list = []
+    for pv in scale_list:
+        composed_transforms_ts = transforms.Compose([
+            tr.Scale_only_img(pv),
+            tr.Normalize_xception_tf_only_img(),
+            tr.ToTensor_only_img()])
+
+        composed_transforms_ts_flip = transforms.Compose([
+            tr.Scale_only_img(pv),
+            tr.HorizontalFlip_only_img(),
+            tr.Normalize_xception_tf_only_img(),
+            tr.ToTensor_only_img()])
+
+        testloader_list.append(img_transform(img, composed_transforms_ts))
+        # print(img_transform(img, composed_transforms_ts))
+        testloader_flip_list.append(img_transform(img, composed_transforms_ts_flip))
+    # print(testloader_list)
+    start_time = timeit.default_timer()
+    # One testing epoch
+    net.eval()
+    # 1 0.5 0.75 1.25 1.5 1.75 ; flip:
+
+    for iii, sample_batched in enumerate(zip(testloader_list, testloader_flip_list)):
+        inputs, labels = sample_batched[0]['image'], sample_batched[0]['label']
+        inputs_f, _ = sample_batched[1]['image'], sample_batched[1]['label']
+        inputs = inputs.unsqueeze(0)
+        inputs_f = inputs_f.unsqueeze(0)
+        inputs = torch.cat((inputs, inputs_f), dim=0)
+        if iii == 0:
+            _, _, h, w = inputs.size()
+        # assert inputs.size() == inputs_f.size()
+
+        # Forward pass of the mini-batch
+        inputs = Variable(inputs, requires_grad=False)
+
+        with torch.no_grad():
+            if use_gpu >= 0:
+                inputs = inputs.cuda()
+            # outputs = net.forward(inputs)
+            outputs = net.forward(inputs, adj1_test.cuda(), adj3_test.cuda(), adj2_test.cuda())
+            outputs = (outputs[0] + flip(flip_cihp(outputs[1]), dim=-1)) / 2
+            outputs = outputs.unsqueeze(0)
+
+            if iii > 0:
+                outputs = F.upsample(outputs, size=(h, w), mode='bilinear', align_corners=True)
+                outputs_final = outputs_final + outputs
+            else:
+                outputs_final = outputs.clone()
+    ################ plot pic
+    predictions = torch.max(outputs_final, 1)[1]
+    results = predictions.cpu().numpy()
+    vis_res = decode_labels(results)
+
+    parsing_im = Image.fromarray(vis_res[0])
+    parsing_im.save(output_path+'/{}.png'.format(output_name))
+    cv2.imwrite(output_path+'/{}_gray.png'.format(output_name), results[0, :, :])
+
+    end_time = timeit.default_timer()
+    print('time used for the multi-scale image inference' + ' is :' + str(end_time - start_time))
+
+if __name__ == '__main__':
+    '''argparse begin'''
+    parser = argparse.ArgumentParser()
+    # parser.add_argument('--loadmodel',default=None,type=str)
+    parser.add_argument('--loadmodel', default='', type=str)
+    parser.add_argument('--img_path', default='', type=str)
+    parser.add_argument('--output_path', default='', type=str)
+    parser.add_argument('--output_name', default='', type=str)
+    parser.add_argument('--use_gpu', default=1, type=int)
+    opts = parser.parse_args()
+
+    net = deeplab_xception_transfer.deeplab_xception_transfer_projection_savemem(n_classes=20,
+                                                                                 hidden_layers=128,
+                                                                                 source_classes=7, )
+    if not opts.loadmodel == '':
+        x = torch.load(opts.loadmodel)
+        net.load_source_model(x)
+        print('load model:', opts.loadmodel)
+    else:
+        print('no model load !!!!!!!!')
+        raise RuntimeError('No model!!!!')
+
+    if opts.use_gpu >0 :
+        net.cuda()
+        use_gpu = True
+    else:
+        use_gpu = False
+        raise RuntimeError('must use the gpu!!!!')
+
+    inference(net=net, img_path=opts.img_path,output_path=opts.output_path , output_name=opts.output_name, use_gpu=use_gpu)
+

TryYours-Virtual-Try-On/Graphonomy-master/exp/inference/inference.py

@@ -0,0 +1,206 @@
+import socket
+import timeit
+import numpy as np
+from PIL import Image
+from datetime import datetime
+import os
+import sys
+from collections import OrderedDict
+sys.path.append('./')
+# PyTorch includes
+import torch
+from torch.autograd import Variable
+from torchvision import transforms
+import cv2
+
+
+# Custom includes
+from networks import deeplab_xception_transfer, graph
+from dataloaders import custom_transforms as tr
+
+#
+import argparse
+import torch.nn.functional as F
+
+import warnings
+warnings.filterwarnings("ignore")
+
+label_colours = [(0,0,0)
+                , (128,0,0), (255,0,0), (0,85,0), (170,0,51), (255,85,0), (0,0,85), (0,119,221), (85,85,0), (0,85,85), (85,51,0), (52,86,128), (0,128,0)
+                , (0,0,255), (51,170,221), (0,255,255), (85,255,170), (170,255,85), (255,255,0), (255,170,0)]
+
+
+def flip(x, dim):
+    indices = [slice(None)] * x.dim()
+    indices[dim] = torch.arange(x.size(dim) - 1, -1, -1,
+                                dtype=torch.long, device=x.device)
+    return x[tuple(indices)]
+
+def flip_cihp(tail_list):
+    '''
+
+    :param tail_list: tail_list size is 1 x n_class x h x w
+    :return:
+    '''
+    # tail_list = tail_list[0]
+    tail_list_rev = [None] * 20
+    for xx in range(14):
+        tail_list_rev[xx] = tail_list[xx].unsqueeze(0)
+    tail_list_rev[14] = tail_list[15].unsqueeze(0)
+    tail_list_rev[15] = tail_list[14].unsqueeze(0)
+    tail_list_rev[16] = tail_list[17].unsqueeze(0)
+    tail_list_rev[17] = tail_list[16].unsqueeze(0)
+    tail_list_rev[18] = tail_list[19].unsqueeze(0)
+    tail_list_rev[19] = tail_list[18].unsqueeze(0)
+    return torch.cat(tail_list_rev,dim=0)
+
+
+def decode_labels(mask, num_images=1, num_classes=20):
+    """Decode batch of segmentation masks.
+
+    Args:
+      mask: result of inference after taking argmax.
+      num_images: number of images to decode from the batch.
+      num_classes: number of classes to predict (including background).
+
+    Returns:
+      A batch with num_images RGB images of the same size as the input.
+    """
+    n, h, w = mask.shape
+    assert (n >= num_images), 'Batch size %d should be greater or equal than number of images to save %d.' % (
+    n, num_images)
+    outputs = np.zeros((num_images, h, w, 3), dtype=np.uint8)
+    for i in range(num_images):
+        img = Image.new('RGB', (len(mask[i, 0]), len(mask[i])))
+        pixels = img.load()
+        for j_, j in enumerate(mask[i, :, :]):
+            for k_, k in enumerate(j):
+                if k < num_classes:
+                    pixels[k_, j_] = label_colours[k]
+        outputs[i] = np.array(img)
+    return outputs
+
+def read_img(img_path):
+    _img = Image.open(img_path).convert('RGB')  # return is RGB pic
+    return _img
+
+def img_transform(img, transform=None):
+    sample = {'image': img, 'label': 0}
+
+    sample = transform(sample)
+    return sample
+
+def inference(net, img_path='', output_path='./', output_name='f', use_gpu=True):
+    '''
+
+    :param net:
+    :param img_path:
+    :param output_path:
+    :return:
+    '''
+    # adj
+    adj2_ = torch.from_numpy(graph.cihp2pascal_nlp_adj).float()
+    adj2_test = adj2_.unsqueeze(0).unsqueeze(0).expand(1, 1, 7, 20).cuda().transpose(2, 3)
+
+    adj1_ = Variable(torch.from_numpy(graph.preprocess_adj(graph.pascal_graph)).float())
+    adj3_test = adj1_.unsqueeze(0).unsqueeze(0).expand(1, 1, 7, 7).cuda()
+
+    cihp_adj = graph.preprocess_adj(graph.cihp_graph)
+    adj3_ = Variable(torch.from_numpy(cihp_adj).float())
+    adj1_test = adj3_.unsqueeze(0).unsqueeze(0).expand(1, 1, 20, 20).cuda()
+
+    # multi-scale
+    scale_list = [1, 0.5, 0.75, 1.25, 1.5, 1.75]
+    img = read_img(img_path)
+    testloader_list = []
+    testloader_flip_list = []
+    for pv in scale_list:
+        composed_transforms_ts = transforms.Compose([
+            tr.Scale_only_img(pv),
+            tr.Normalize_xception_tf_only_img(),
+            tr.ToTensor_only_img()])
+
+        composed_transforms_ts_flip = transforms.Compose([
+            tr.Scale_only_img(pv),
+            tr.HorizontalFlip_only_img(),
+            tr.Normalize_xception_tf_only_img(),
+            tr.ToTensor_only_img()])
+
+        testloader_list.append(img_transform(img, composed_transforms_ts))
+        # print(img_transform(img, composed_transforms_ts))
+        testloader_flip_list.append(img_transform(img, composed_transforms_ts_flip))
+    # print(testloader_list)
+    start_time = timeit.default_timer()
+    # One testing epoch
+    net.eval()
+    # 1 0.5 0.75 1.25 1.5 1.75 ; flip:
+
+    for iii, sample_batched in enumerate(zip(testloader_list, testloader_flip_list)):
+        inputs, labels = sample_batched[0]['image'], sample_batched[0]['label']
+        inputs_f, _ = sample_batched[1]['image'], sample_batched[1]['label']
+        inputs = inputs.unsqueeze(0)
+        inputs_f = inputs_f.unsqueeze(0)
+        inputs = torch.cat((inputs, inputs_f), dim=0)
+        if iii == 0:
+            _, _, h, w = inputs.size()
+        # assert inputs.size() == inputs_f.size()
+
+        # Forward pass of the mini-batch
+        inputs = Variable(inputs, requires_grad=False)
+
+        with torch.no_grad():
+            if use_gpu >= 0:
+                inputs = inputs.cuda()
+            # outputs = net.forward(inputs)
+            outputs = net.forward(inputs, adj1_test.cuda(), adj3_test.cuda(), adj2_test.cuda())
+            outputs = (outputs[0] + flip(flip_cihp(outputs[1]), dim=-1)) / 2
+            outputs = outputs.unsqueeze(0)
+
+            if iii > 0:
+                outputs = F.upsample(outputs, size=(h, w), mode='bilinear', align_corners=True)
+                outputs_final = outputs_final + outputs
+            else:
+                outputs_final = outputs.clone()
+    ################ plot pic
+    predictions = torch.max(outputs_final, 1)[1]
+    results = predictions.cpu().numpy()
+    vis_res = decode_labels(results)
+
+    parsing_im = Image.fromarray(vis_res[0])
+    parsing_im.save(output_path+'/{}.png'.format(output_name))
+    cv2.imwrite(output_path+'/{}_gray.png'.format(output_name), results[0, :, :])
+
+    end_time = timeit.default_timer()
+    print('time used for the multi-scale image inference' + ' is :' + str(end_time - start_time))
+
+if __name__ == '__main__':
+    '''argparse begin'''
+    parser = argparse.ArgumentParser()
+    # parser.add_argument('--loadmodel',default=None,type=str)
+    parser.add_argument('--loadmodel', default='', type=str)
+    parser.add_argument('--img_path', default='', type=str)
+    parser.add_argument('--output_path', default='', type=str)
+    parser.add_argument('--output_name', default='', type=str)
+    parser.add_argument('--use_gpu', default=1, type=int)
+    opts = parser.parse_args()
+
+    net = deeplab_xception_transfer.deeplab_xception_transfer_projection_savemem(n_classes=20,
+                                                                                 hidden_layers=128,
+                                                                                 source_classes=7, )
+    if not opts.loadmodel == '':
+        x = torch.load(opts.loadmodel)
+        net.load_source_model(x)
+        print('load model:', opts.loadmodel)
+    else:
+        print('no model load !!!!!!!!')
+        raise RuntimeError('No model!!!!')
+
+    if opts.use_gpu >0 :
+        net.cuda()
+        use_gpu = True
+    else:
+        use_gpu = False
+        raise RuntimeError('must use the gpu!!!!')
+
+    inference(net=net, img_path=opts.img_path,output_path=opts.output_path , output_name=opts.output_name, use_gpu=use_gpu)
+

TryYours-Virtual-Try-On/Graphonomy-master/exp/test/__init__.py

@@ -0,0 +1,3 @@
+from .test_from_disk import eval_
+
+__all__ = ['eval_']

TryYours-Virtual-Try-On/Graphonomy-master/exp/test/eval_show_cihp2pascal.py

@@ -0,0 +1,268 @@
+import socket
+import timeit
+import numpy as np
+from PIL import Image
+from datetime import datetime
+import os
+import sys
+import glob
+from collections import OrderedDict
+sys.path.append('../../')
+# PyTorch includes
+import torch
+import pdb
+from torch.autograd import Variable
+import torch.optim as optim
+from torchvision import transforms
+from torch.utils.data import DataLoader
+from torchvision.utils import make_grid
+import cv2
+
+# Tensorboard include
+# from tensorboardX import SummaryWriter
+
+# Custom includes
+from dataloaders import pascal
+from utils import util
+from networks import deeplab_xception_transfer, graph
+from dataloaders import custom_transforms as tr
+
+#
+import argparse
+import copy
+import torch.nn.functional as F
+from test_from_disk import eval_
+
+
+gpu_id = 1
+
+label_colours = [(0,0,0)
+                # 0=background
+                ,(128,0,0), (0,128,0), (128,128,0), (0,0,128), (128,0,128), (0,128,128)]
+
+
+def flip(x, dim):
+    indices = [slice(None)] * x.dim()
+    indices[dim] = torch.arange(x.size(dim) - 1, -1, -1,
+                                dtype=torch.long, device=x.device)
+    return x[tuple(indices)]
+
+# def flip_cihp(tail_list):
+#     '''
+#
+#     :param tail_list: tail_list size is 1 x n_class x h x w
+#     :return:
+#     '''
+#     # tail_list = tail_list[0]
+#     tail_list_rev = [None] * 20
+#     for xx in range(14):
+#         tail_list_rev[xx] = tail_list[xx].unsqueeze(0)
+#     tail_list_rev[14] = tail_list[15].unsqueeze(0)
+#     tail_list_rev[15] = tail_list[14].unsqueeze(0)
+#     tail_list_rev[16] = tail_list[17].unsqueeze(0)
+#     tail_list_rev[17] = tail_list[16].unsqueeze(0)
+#     tail_list_rev[18] = tail_list[19].unsqueeze(0)
+#     tail_list_rev[19] = tail_list[18].unsqueeze(0)
+#     return torch.cat(tail_list_rev,dim=0)
+
+def decode_labels(mask, num_images=1, num_classes=20):
+    """Decode batch of segmentation masks.
+    
+    Args:
+      mask: result of inference after taking argmax.
+      num_images: number of images to decode from the batch.
+      num_classes: number of classes to predict (including background).
+    
+    Returns:
+      A batch with num_images RGB images of the same size as the input. 
+    """
+    n, h, w = mask.shape
+    assert(n >= num_images), 'Batch size %d should be greater or equal than number of images to save %d.' % (n, num_images)
+    outputs = np.zeros((num_images, h, w, 3), dtype=np.uint8)
+    for i in range(num_images):
+      img = Image.new('RGB', (len(mask[i, 0]), len(mask[i])))
+      pixels = img.load()
+      for j_, j in enumerate(mask[i, :, :]):
+          for k_, k in enumerate(j):
+              if k < num_classes:
+                  pixels[k_,j_] = label_colours[k]
+      outputs[i] = np.array(img)
+    return outputs
+
+def get_parser():
+    '''argparse begin'''
+    parser = argparse.ArgumentParser()
+    LookupChoices = type('', (argparse.Action,), dict(__call__=lambda a, p, n, v, o: setattr(n, a.dest, a.choices[v])))
+
+    parser.add_argument('--epochs', default=100, type=int)
+    parser.add_argument('--batch', default=16, type=int)
+    parser.add_argument('--lr', default=1e-7, type=float)
+    parser.add_argument('--numworker', default=12, type=int)
+    parser.add_argument('--step', default=30, type=int)
+    # parser.add_argument('--loadmodel',default=None,type=str)
+    parser.add_argument('--classes', default=7, type=int)
+    parser.add_argument('--testepoch', default=10, type=int)
+    parser.add_argument('--loadmodel', default='', type=str)
+    parser.add_argument('--txt_file', default='', type=str)
+    parser.add_argument('--hidden_layers', default=128, type=int)
+    parser.add_argument('--gpus', default=4, type=int)
+    parser.add_argument('--output_path', default='./results/', type=str)
+    parser.add_argument('--gt_path', default='./results/', type=str)
+    opts = parser.parse_args()
+    return opts
+
+
+def main(opts):
+    adj2_ = torch.from_numpy(graph.cihp2pascal_nlp_adj).float()
+    adj2_test = adj2_.unsqueeze(0).unsqueeze(0).expand(1, 1, 7, 20).cuda()
+
+    adj1_ = Variable(torch.from_numpy(graph.preprocess_adj(graph.pascal_graph)).float())
+    adj1_test = adj1_.unsqueeze(0).unsqueeze(0).expand(1, 1, 7, 7).cuda()
+
+    cihp_adj = graph.preprocess_adj(graph.cihp_graph)
+    adj3_ = Variable(torch.from_numpy(cihp_adj).float())
+    adj3_test = adj3_.unsqueeze(0).unsqueeze(0).expand(1, 1, 20, 20).cuda()
+
+    p = OrderedDict()  # Parameters to include in report
+    p['trainBatch'] = opts.batch  # Training batch size
+    p['nAveGrad'] = 1  # Average the gradient of several iterations
+    p['lr'] = opts.lr  # Learning rate
+    p['lrFtr'] = 1e-5
+    p['lraspp'] = 1e-5
+    p['lrpro'] = 1e-5
+    p['lrdecoder'] = 1e-5
+    p['lrother']  = 1e-5
+    p['wd'] = 5e-4  # Weight decay
+    p['momentum'] = 0.9  # Momentum
+    p['epoch_size'] = 10  # How many epochs to change learning rate
+    p['num_workers'] = opts.numworker
+    backbone = 'xception' # Use xception or resnet as feature extractor,
+
+    with open(opts.txt_file, 'r') as f:
+        img_list = f.readlines()
+
+    max_id = 0
+    save_dir_root = os.path.join(os.path.dirname(os.path.abspath(__file__)))
+    exp_name = os.path.dirname(os.path.abspath(__file__)).split('/')[-1]
+    runs = glob.glob(os.path.join(save_dir_root, 'run', 'run_*'))
+    for r in runs:
+        run_id = int(r.split('_')[-1])
+        if run_id >= max_id:
+            max_id = run_id + 1
+    # run_id = int(runs[-1].split('_')[-1]) + 1 if runs else 0
+
+    # Network definition
+    if backbone == 'xception':
+        net = deeplab_xception_transfer.deeplab_xception_transfer_projection(n_classes=opts.classes, os=16,
+                                                                                     hidden_layers=opts.hidden_layers, source_classes=20,
+                                                                                     )
+    elif backbone == 'resnet':
+        # net = deeplab_resnet.DeepLabv3_plus(nInputChannels=3, n_classes=7, os=16, pretrained=True)
+        raise NotImplementedError
+    else:
+        raise NotImplementedError
+
+    if gpu_id >= 0:
+        net.cuda()
+
+    # net load weights
+    if not opts.loadmodel =='':
+        x = torch.load(opts.loadmodel)
+        net.load_source_model(x)
+        print('load model:' ,opts.loadmodel)
+    else:
+        print('no model load !!!!!!!!')
+
+    ## multi scale
+    scale_list=[1,0.5,0.75,1.25,1.5,1.75]
+    testloader_list = []
+    testloader_flip_list = []
+    for pv in scale_list:
+        composed_transforms_ts = transforms.Compose([
+            tr.Scale_(pv),
+            tr.Normalize_xception_tf(),
+            tr.ToTensor_()])
+
+        composed_transforms_ts_flip = transforms.Compose([
+            tr.Scale_(pv),
+            tr.HorizontalFlip(),
+            tr.Normalize_xception_tf(),
+            tr.ToTensor_()])
+
+        voc_val = pascal.VOCSegmentation(split='val', transform=composed_transforms_ts)
+        voc_val_f = pascal.VOCSegmentation(split='val', transform=composed_transforms_ts_flip)
+
+        testloader = DataLoader(voc_val, batch_size=1, shuffle=False, num_workers=p['num_workers'])
+        testloader_flip = DataLoader(voc_val_f, batch_size=1, shuffle=False, num_workers=p['num_workers'])
+
+        testloader_list.append(copy.deepcopy(testloader))
+        testloader_flip_list.append(copy.deepcopy(testloader_flip))
+
+    print("Eval Network")
+
+    if not os.path.exists(opts.output_path + 'pascal_output_vis/'):
+        os.makedirs(opts.output_path + 'pascal_output_vis/')
+    if not os.path.exists(opts.output_path + 'pascal_output/'):
+        os.makedirs(opts.output_path + 'pascal_output/')
+
+    start_time = timeit.default_timer()
+    # One testing epoch
+    total_iou = 0.0
+    net.eval()
+    for ii, large_sample_batched in enumerate(zip(*testloader_list, *testloader_flip_list)):
+        print(ii)
+        #1 0.5 0.75 1.25 1.5 1.75 ; flip:
+        sample1 = large_sample_batched[:6]
+        sample2 = large_sample_batched[6:]
+        for iii,sample_batched in enumerate(zip(sample1,sample2)):
+            inputs, labels = sample_batched[0]['image'], sample_batched[0]['label']
+            inputs_f, _ = sample_batched[1]['image'], sample_batched[1]['label']
+            inputs = torch.cat((inputs,inputs_f),dim=0)
+            if iii == 0:
+                _,_,h,w = inputs.size()
+            # assert inputs.size() == inputs_f.size()
+
+            # Forward pass of the mini-batch
+            inputs, labels = Variable(inputs, requires_grad=False), Variable(labels)
+
+            with torch.no_grad():
+                if gpu_id >= 0:
+                    inputs, labels = inputs.cuda(), labels.cuda()
+                # outputs = net.forward(inputs)
+                # pdb.set_trace()
+                outputs = net.forward(inputs, adj1_test.cuda(), adj3_test.cuda(), adj2_test.cuda())
+                outputs = (outputs[0] + flip(outputs[1], dim=-1)) / 2
+                outputs = outputs.unsqueeze(0)
+
+                if iii>0:
+                    outputs = F.upsample(outputs,size=(h,w),mode='bilinear',align_corners=True)
+                    outputs_final = outputs_final + outputs
+                else:
+                    outputs_final = outputs.clone()
+        ################ plot pic
+        predictions = torch.max(outputs_final, 1)[1]
+        prob_predictions = torch.max(outputs_final,1)[0]
+        results = predictions.cpu().numpy()
+        prob_results = prob_predictions.cpu().numpy()
+        vis_res = decode_labels(results)
+
+        parsing_im = Image.fromarray(vis_res[0])
+        parsing_im.save(opts.output_path + 'pascal_output_vis/{}.png'.format(img_list[ii][:-1]))
+        cv2.imwrite(opts.output_path + 'pascal_output/{}.png'.format(img_list[ii][:-1]), results[0,:,:])
+        # np.save('../../cihp_prob_output/{}.npy'.format(img_list[ii][:-1]), prob_results[0, :, :])
+        # pred_list.append(predictions.cpu())
+        # label_list.append(labels.squeeze(1).cpu())
+        # loss = criterion(outputs, labels, batch_average=True)
+        # running_loss_ts += loss.item()
+
+        # total_iou += utils.get_iou(predictions, labels)
+    end_time = timeit.default_timer()
+    print('time use for '+str(ii) + ' is :' + str(end_time - start_time))
+
+    # Eval
+    pred_path = opts.output_path + 'pascal_output/'
+    eval_(pred_path=pred_path, gt_path=opts.gt_path,classes=opts.classes, txt_file=opts.txt_file)
+
+if __name__ == '__main__':
+    opts = get_parser()
+    main(opts)

TryYours-Virtual-Try-On/Graphonomy-master/exp/test/eval_show_pascal2cihp.py

@@ -0,0 +1,268 @@
+import socket
+import timeit
+import numpy as np
+from PIL import Image
+from datetime import datetime
+import os
+import sys
+import glob
+from collections import OrderedDict
+sys.path.append('../../')
+# PyTorch includes
+import torch
+import pdb
+from torch.autograd import Variable
+import torch.optim as optim
+from torchvision import transforms
+from torch.utils.data import DataLoader
+from torchvision.utils import make_grid
+import cv2
+
+# Tensorboard include
+# from tensorboardX import SummaryWriter
+
+# Custom includes
+from dataloaders import  cihp
+from utils import util
+from networks import deeplab_xception_transfer, graph
+from dataloaders import custom_transforms as tr
+
+#
+import argparse
+import copy
+import torch.nn.functional as F
+from test_from_disk import eval_
+
+
+gpu_id = 1
+
+label_colours = [(0,0,0)
+                , (128,0,0), (255,0,0), (0,85,0), (170,0,51), (255,85,0), (0,0,85), (0,119,221), (85,85,0), (0,85,85), (85,51,0), (52,86,128), (0,128,0)
+                , (0,0,255), (51,170,221), (0,255,255), (85,255,170), (170,255,85), (255,255,0), (255,170,0)]
+
+
+def flip(x, dim):
+    indices = [slice(None)] * x.dim()
+    indices[dim] = torch.arange(x.size(dim) - 1, -1, -1,
+                                dtype=torch.long, device=x.device)
+    return x[tuple(indices)]
+
+def flip_cihp(tail_list):
+    '''
+
+    :param tail_list: tail_list size is 1 x n_class x h x w
+    :return:
+    '''
+    # tail_list = tail_list[0]
+    tail_list_rev = [None] * 20
+    for xx in range(14):
+        tail_list_rev[xx] = tail_list[xx].unsqueeze(0)
+    tail_list_rev[14] = tail_list[15].unsqueeze(0)
+    tail_list_rev[15] = tail_list[14].unsqueeze(0)
+    tail_list_rev[16] = tail_list[17].unsqueeze(0)
+    tail_list_rev[17] = tail_list[16].unsqueeze(0)
+    tail_list_rev[18] = tail_list[19].unsqueeze(0)
+    tail_list_rev[19] = tail_list[18].unsqueeze(0)
+    return torch.cat(tail_list_rev,dim=0)
+
+def decode_labels(mask, num_images=1, num_classes=20):
+    """Decode batch of segmentation masks.
+    
+    Args:
+      mask: result of inference after taking argmax.
+      num_images: number of images to decode from the batch.
+      num_classes: number of classes to predict (including background).
+    
+    Returns:
+      A batch with num_images RGB images of the same size as the input. 
+    """
+    n, h, w = mask.shape
+    assert(n >= num_images), 'Batch size %d should be greater or equal than number of images to save %d.' % (n, num_images)
+    outputs = np.zeros((num_images, h, w, 3), dtype=np.uint8)
+    for i in range(num_images):
+      img = Image.new('RGB', (len(mask[i, 0]), len(mask[i])))
+      pixels = img.load()
+      for j_, j in enumerate(mask[i, :, :]):
+          for k_, k in enumerate(j):
+              if k < num_classes:
+                  pixels[k_,j_] = label_colours[k]
+      outputs[i] = np.array(img)
+    return outputs
+
+def get_parser():
+    '''argparse begin'''
+    parser = argparse.ArgumentParser()
+    LookupChoices = type('', (argparse.Action,), dict(__call__=lambda a, p, n, v, o: setattr(n, a.dest, a.choices[v])))
+
+    parser.add_argument('--epochs', default=100, type=int)
+    parser.add_argument('--batch', default=16, type=int)
+    parser.add_argument('--lr', default=1e-7, type=float)
+    parser.add_argument('--numworker', default=12, type=int)
+    parser.add_argument('--step', default=30, type=int)
+    # parser.add_argument('--loadmodel',default=None,type=str)
+    parser.add_argument('--classes', default=7, type=int)
+    parser.add_argument('--testepoch', default=10, type=int)
+    parser.add_argument('--loadmodel', default='', type=str)
+    parser.add_argument('--txt_file', default='', type=str)
+    parser.add_argument('--hidden_layers', default=128, type=int)
+    parser.add_argument('--gpus', default=4, type=int)
+    parser.add_argument('--output_path', default='./results/', type=str)
+    parser.add_argument('--gt_path', default='./results/', type=str)
+    opts = parser.parse_args()
+    return opts
+
+
+def main(opts):
+    adj2_ = torch.from_numpy(graph.cihp2pascal_nlp_adj).float()
+    adj2_test = adj2_.unsqueeze(0).unsqueeze(0).expand(1, 1, 7, 20).cuda().transpose(2, 3)
+
+    adj1_ = Variable(torch.from_numpy(graph.preprocess_adj(graph.pascal_graph)).float())
+    adj3_test = adj1_.unsqueeze(0).unsqueeze(0).expand(1, 1, 7, 7).cuda()
+
+    cihp_adj = graph.preprocess_adj(graph.cihp_graph)
+    adj3_ = Variable(torch.from_numpy(cihp_adj).float())
+    adj1_test = adj3_.unsqueeze(0).unsqueeze(0).expand(1, 1, 20, 20).cuda()
+
+    p = OrderedDict()  # Parameters to include in report
+    p['trainBatch'] = opts.batch  # Training batch size
+    p['nAveGrad'] = 1  # Average the gradient of several iterations
+    p['lr'] = opts.lr  # Learning rate
+    p['lrFtr'] = 1e-5
+    p['lraspp'] = 1e-5
+    p['lrpro'] = 1e-5
+    p['lrdecoder'] = 1e-5
+    p['lrother']  = 1e-5
+    p['wd'] = 5e-4  # Weight decay
+    p['momentum'] = 0.9  # Momentum
+    p['epoch_size'] = 10  # How many epochs to change learning rate
+    p['num_workers'] = opts.numworker
+    backbone = 'xception' # Use xception or resnet as feature extractor,
+
+    with open(opts.txt_file, 'r') as f:
+        img_list = f.readlines()
+
+    max_id = 0
+    save_dir_root = os.path.join(os.path.dirname(os.path.abspath(__file__)))
+    exp_name = os.path.dirname(os.path.abspath(__file__)).split('/')[-1]
+    runs = glob.glob(os.path.join(save_dir_root, 'run', 'run_*'))
+    for r in runs:
+        run_id = int(r.split('_')[-1])
+        if run_id >= max_id:
+            max_id = run_id + 1
+    # run_id = int(runs[-1].split('_')[-1]) + 1 if runs else 0
+
+    # Network definition
+    if backbone == 'xception':
+        net = deeplab_xception_transfer.deeplab_xception_transfer_projection_savemem(n_classes=opts.classes, os=16,
+                                                                                     hidden_layers=opts.hidden_layers, source_classes=7,
+                                                                                     )
+    elif backbone == 'resnet':
+        # net = deeplab_resnet.DeepLabv3_plus(nInputChannels=3, n_classes=7, os=16, pretrained=True)
+        raise NotImplementedError
+    else:
+        raise NotImplementedError
+
+    if gpu_id >= 0:
+        net.cuda()
+
+    # net load weights
+    if not opts.loadmodel =='':
+        x = torch.load(opts.loadmodel)
+        net.load_source_model(x)
+        print('load model:' ,opts.loadmodel)
+    else:
+        print('no model load !!!!!!!!')
+
+    ## multi scale
+    scale_list=[1,0.5,0.75,1.25,1.5,1.75]
+    testloader_list = []
+    testloader_flip_list = []
+    for pv in scale_list:
+        composed_transforms_ts = transforms.Compose([
+            tr.Scale_(pv),
+            tr.Normalize_xception_tf(),
+            tr.ToTensor_()])
+
+        composed_transforms_ts_flip = transforms.Compose([
+            tr.Scale_(pv),
+            tr.HorizontalFlip(),
+            tr.Normalize_xception_tf(),
+            tr.ToTensor_()])
+
+        voc_val = cihp.VOCSegmentation(split='test', transform=composed_transforms_ts)
+        voc_val_f = cihp.VOCSegmentation(split='test', transform=composed_transforms_ts_flip)
+
+        testloader = DataLoader(voc_val, batch_size=1, shuffle=False, num_workers=p['num_workers'])
+        testloader_flip = DataLoader(voc_val_f, batch_size=1, shuffle=False, num_workers=p['num_workers'])
+
+        testloader_list.append(copy.deepcopy(testloader))
+        testloader_flip_list.append(copy.deepcopy(testloader_flip))
+
+    print("Eval Network")
+
+    if not os.path.exists(opts.output_path + 'cihp_output_vis/'):
+        os.makedirs(opts.output_path + 'cihp_output_vis/')
+    if not os.path.exists(opts.output_path + 'cihp_output/'):
+        os.makedirs(opts.output_path + 'cihp_output/')
+
+    start_time = timeit.default_timer()
+    # One testing epoch
+    total_iou = 0.0
+    net.eval()
+    for ii, large_sample_batched in enumerate(zip(*testloader_list, *testloader_flip_list)):
+        print(ii)
+        #1 0.5 0.75 1.25 1.5 1.75 ; flip:
+        sample1 = large_sample_batched[:6]
+        sample2 = large_sample_batched[6:]
+        for iii,sample_batched in enumerate(zip(sample1,sample2)):
+            inputs, labels = sample_batched[0]['image'], sample_batched[0]['label']
+            inputs_f, _ = sample_batched[1]['image'], sample_batched[1]['label']
+            inputs = torch.cat((inputs,inputs_f),dim=0)
+            if iii == 0:
+                _,_,h,w = inputs.size()
+            # assert inputs.size() == inputs_f.size()
+
+            # Forward pass of the mini-batch
+            inputs, labels = Variable(inputs, requires_grad=False), Variable(labels)
+
+            with torch.no_grad():
+                if gpu_id >= 0:
+                    inputs, labels = inputs.cuda(), labels.cuda()
+                # outputs = net.forward(inputs)
+                # pdb.set_trace()
+                outputs = net.forward(inputs, adj1_test.cuda(), adj3_test.cuda(), adj2_test.cuda())
+                outputs = (outputs[0] + flip(flip_cihp(outputs[1]), dim=-1)) / 2
+                outputs = outputs.unsqueeze(0)
+
+                if iii>0:
+                    outputs = F.upsample(outputs,size=(h,w),mode='bilinear',align_corners=True)
+                    outputs_final = outputs_final + outputs
+                else:
+                    outputs_final = outputs.clone()
+        ################ plot pic
+        predictions = torch.max(outputs_final, 1)[1]
+        prob_predictions = torch.max(outputs_final,1)[0]
+        results = predictions.cpu().numpy()
+        prob_results = prob_predictions.cpu().numpy()
+        vis_res = decode_labels(results)
+
+        parsing_im = Image.fromarray(vis_res[0])
+        parsing_im.save(opts.output_path + 'cihp_output_vis/{}.png'.format(img_list[ii][:-1]))
+        cv2.imwrite(opts.output_path + 'cihp_output/{}.png'.format(img_list[ii][:-1]), results[0,:,:])
+        # np.save('../../cihp_prob_output/{}.npy'.format(img_list[ii][:-1]), prob_results[0, :, :])
+        # pred_list.append(predictions.cpu())
+        # label_list.append(labels.squeeze(1).cpu())
+        # loss = criterion(outputs, labels, batch_average=True)
+        # running_loss_ts += loss.item()
+
+        # total_iou += utils.get_iou(predictions, labels)
+    end_time = timeit.default_timer()
+    print('time use for '+str(ii) + ' is :' + str(end_time - start_time))
+
+    # Eval
+    pred_path = opts.output_path + 'cihp_output/'
+    eval_(pred_path=pred_path, gt_path=opts.gt_path,classes=opts.classes, txt_file=opts.txt_file)
+
+if __name__ == '__main__':
+    opts = get_parser()
+    main(opts)

TryYours-Virtual-Try-On/Graphonomy-master/exp/test/test_from_disk.py

@@ -0,0 +1,65 @@
+import sys
+sys.path.append('./')
+# PyTorch includes
+import torch
+import numpy as np
+
+from utils import test_human
+from PIL import Image
+
+#
+import argparse
+
+def get_parser():
+    '''argparse begin'''
+    parser = argparse.ArgumentParser()
+    LookupChoices = type('', (argparse.Action,), dict(__call__=lambda a, p, n, v, o: setattr(n, a.dest, a.choices[v])))
+
+    parser.add_argument('--epochs', default=100, type=int)
+    parser.add_argument('--batch', default=16, type=int)
+    parser.add_argument('--lr', default=1e-7, type=float)
+    parser.add_argument('--numworker',default=12,type=int)
+    parser.add_argument('--freezeBN', choices=dict(true=True, false=False), default=True, action=LookupChoices)
+    parser.add_argument('--step', default=30, type=int)
+    parser.add_argument('--txt_file',default=None,type=str)
+    parser.add_argument('--pred_path',default=None,type=str)
+    parser.add_argument('--gt_path',default=None,type=str)
+    parser.add_argument('--classes', default=7, type=int)
+    parser.add_argument('--testepoch', default=10, type=int)
+    opts = parser.parse_args()
+    return opts
+
+def eval_(pred_path, gt_path, classes, txt_file):
+    pred_path = pred_path
+    gt_path = gt_path
+
+    with open(txt_file,) as f:
+        lines = f.readlines()
+        lines = [x.strip() for x in lines]
+
+    output_list = []
+    label_list = []
+    for i,file in enumerate(lines):
+        print(i)
+        file_name = file + '.png'
+        try:
+            predict_pic = np.array(Image.open(pred_path+file_name))
+            gt_pic = np.array(Image.open(gt_path+file_name))
+            output_list.append(torch.from_numpy(predict_pic))
+            label_list.append(torch.from_numpy(gt_pic))
+        except:
+            print(file_name,flush=True)
+            raise RuntimeError('no predict/gt image.')
+            # gt_pic = np.array(Image.open(gt_path + file_name))
+            # output_list.append(torch.from_numpy(gt_pic))
+            # label_list.append(torch.from_numpy(gt_pic))
+
+
+    miou = test_human.get_iou_from_list(output_list, label_list, n_cls=classes)
+
+    print('Validation:')
+    print('MIoU: %f\n' % miou)
+
+if __name__ == '__main__':
+    opts = get_parser()
+    eval_(pred_path=opts.pred_path, gt_path=opts.gt_path, classes=opts.classes, txt_file=opts.txt_file)

TryYours-Virtual-Try-On/Graphonomy-master/exp/transfer/train_cihp_from_pascal.py

@@ -0,0 +1,331 @@
+import socket
+import timeit
+from datetime import datetime
+import os
+import sys
+import glob
+import numpy as np
+from collections import OrderedDict
+sys.path.append('../../')
+sys.path.append('../../networks/')
+# PyTorch includes
+import torch
+from torch.autograd import Variable
+import torch.optim as optim
+from torchvision import transforms
+from torch.utils.data import DataLoader
+from torchvision.utils import make_grid
+
+
+# Tensorboard include
+from tensorboardX import SummaryWriter
+
+# Custom includes
+from dataloaders import cihp
+from utils import util,get_iou_from_list
+from networks import deeplab_xception_transfer, graph
+from dataloaders import custom_transforms as tr
+
+#
+import argparse
+
+gpu_id = 0
+
+nEpochs = 100  # Number of epochs for training
+resume_epoch = 0   # Default is 0, change if want to resume
+
+def flip(x, dim):
+    indices = [slice(None)] * x.dim()
+    indices[dim] = torch.arange(x.size(dim) - 1, -1, -1,
+                                dtype=torch.long, device=x.device)
+    return x[tuple(indices)]
+
+def flip_cihp(tail_list):
+    '''
+
+    :param tail_list: tail_list size is 1 x n_class x h x w
+    :return:
+    '''
+    # tail_list = tail_list[0]
+    tail_list_rev = [None] * 20
+    for xx in range(14):
+        tail_list_rev[xx] = tail_list[xx].unsqueeze(0)
+    tail_list_rev[14] = tail_list[15].unsqueeze(0)
+    tail_list_rev[15] = tail_list[14].unsqueeze(0)
+    tail_list_rev[16] = tail_list[17].unsqueeze(0)
+    tail_list_rev[17] = tail_list[16].unsqueeze(0)
+    tail_list_rev[18] = tail_list[19].unsqueeze(0)
+    tail_list_rev[19] = tail_list[18].unsqueeze(0)
+    return torch.cat(tail_list_rev,dim=0)
+
+def get_parser():
+    '''argparse begin'''
+    parser = argparse.ArgumentParser()
+    LookupChoices = type('', (argparse.Action,), dict(__call__=lambda a, p, n, v, o: setattr(n, a.dest, a.choices[v])))
+
+    parser.add_argument('--epochs', default=100, type=int)
+    parser.add_argument('--batch', default=16, type=int)
+    parser.add_argument('--lr', default=1e-7, type=float)
+    parser.add_argument('--numworker',default=12,type=int)
+    parser.add_argument('--freezeBN', choices=dict(true=True, false=False), default=True, action=LookupChoices)
+    parser.add_argument('--step', default=10, type=int)
+    parser.add_argument('--classes', default=20, type=int)
+    parser.add_argument('--testInterval', default=10, type=int)
+    parser.add_argument('--loadmodel',default='',type=str)
+    parser.add_argument('--pretrainedModel', default='', type=str)
+    parser.add_argument('--hidden_layers',default=128,type=int)
+    parser.add_argument('--gpus',default=4, type=int)
+
+    opts = parser.parse_args()
+    return opts
+
+def get_graphs(opts):
+    adj2_ = torch.from_numpy(graph.cihp2pascal_nlp_adj).float()
+    adj2 = adj2_.unsqueeze(0).unsqueeze(0).expand(opts.gpus, 1, 7, 20).transpose(2, 3).cuda()
+    adj2_test = adj2_.unsqueeze(0).unsqueeze(0).expand(1, 1, 7, 20).transpose(2, 3)
+
+    adj1_ = Variable(torch.from_numpy(graph.preprocess_adj(graph.pascal_graph)).float())
+    adj3 = adj1_.unsqueeze(0).unsqueeze(0).expand(opts.gpus, 1, 7, 7).cuda()
+    adj3_test = adj1_.unsqueeze(0).unsqueeze(0).expand(1, 1, 7, 7)
+
+    # adj2 = torch.from_numpy(graph.cihp2pascal_adj).float()
+    # adj2 = adj2.unsqueeze(0).unsqueeze(0).expand(opts.gpus, 1, 7, 20)
+    cihp_adj = graph.preprocess_adj(graph.cihp_graph)
+    adj3_ = Variable(torch.from_numpy(cihp_adj).float())
+    adj1 = adj3_.unsqueeze(0).unsqueeze(0).expand(opts.gpus, 1, 20, 20).cuda()
+    adj1_test = adj3_.unsqueeze(0).unsqueeze(0).expand(1, 1, 20, 20)
+    train_graph = [adj1, adj2, adj3]
+    test_graph = [adj1_test, adj2_test, adj3_test]
+    return train_graph, test_graph
+
+
+def val_cihp(net_, testloader, testloader_flip, test_graph, epoch, writer, criterion, classes=20):
+    adj1_test, adj2_test, adj3_test = test_graph
+    num_img_ts = len(testloader)
+    net_.eval()
+    pred_list = []
+    label_list = []
+    running_loss_ts = 0.0
+    miou = 0
+    for ii, sample_batched in enumerate(zip(testloader, testloader_flip)):
+
+        inputs, labels = sample_batched[0]['image'], sample_batched[0]['label']
+        inputs_f, _ = sample_batched[1]['image'], sample_batched[1]['label']
+        inputs = torch.cat((inputs, inputs_f), dim=0)
+        # Forward pass of the mini-batch
+        inputs, labels = Variable(inputs, requires_grad=False), Variable(labels)
+        if gpu_id >= 0:
+            inputs, labels = inputs.cuda(), labels.cuda()
+
+        with torch.no_grad():
+            outputs = net_.forward(inputs, adj1_test.cuda(), adj3_test.cuda(), adj2_test.cuda())
+        # pdb.set_trace()
+        outputs = (outputs[0] + flip(flip_cihp(outputs[1]), dim=-1)) / 2
+        outputs = outputs.unsqueeze(0)
+        predictions = torch.max(outputs, 1)[1]
+        pred_list.append(predictions.cpu())
+        label_list.append(labels.squeeze(1).cpu())
+        loss = criterion(outputs, labels, batch_average=True)
+        running_loss_ts += loss.item()
+        # total_iou += utils.get_iou(predictions, labels)
+        # Print stuff
+        if ii % num_img_ts == num_img_ts - 1:
+            # if ii == 10:
+            miou = get_iou_from_list(pred_list, label_list, n_cls=classes)
+            running_loss_ts = running_loss_ts / num_img_ts
+
+            print('Validation:')
+            print('[Epoch: %d, numImages: %5d]' % (epoch, ii * 1 + inputs.data.shape[0]))
+            writer.add_scalar('data/test_loss_epoch', running_loss_ts, epoch)
+            writer.add_scalar('data/test_miour', miou, epoch)
+            print('Loss: %f' % running_loss_ts)
+            print('MIoU: %f\n' % miou)
+
+
+def main(opts):
+    p = OrderedDict()  # Parameters to include in report
+    p['trainBatch'] = opts.batch  # Training batch size
+    testBatch = 1  # Testing batch size
+    useTest = True  # See evolution of the test set when training
+    nTestInterval = opts.testInterval # Run on test set every nTestInterval epochs
+    snapshot = 1  # Store a model every snapshot epochs
+    p['nAveGrad'] = 1  # Average the gradient of several iterations
+    p['lr'] = opts.lr  # Learning rate
+    p['lrFtr'] = 1e-5
+    p['lraspp'] = 1e-5
+    p['lrpro'] = 1e-5
+    p['lrdecoder'] = 1e-5
+    p['lrother']  = 1e-5
+    p['wd'] = 5e-4  # Weight decay
+    p['momentum'] = 0.9  # Momentum
+    p['epoch_size'] = opts.step  # How many epochs to change learning rate
+    p['num_workers'] = opts.numworker
+    model_path = opts.pretrainedModel
+    backbone = 'xception' # Use xception or resnet as feature extractor,
+    nEpochs = opts.epochs
+
+    max_id = 0
+    save_dir_root = os.path.join(os.path.dirname(os.path.abspath(__file__)))
+    exp_name = os.path.dirname(os.path.abspath(__file__)).split('/')[-1]
+    runs = glob.glob(os.path.join(save_dir_root, 'run_cihp', 'run_*'))
+    for r in runs:
+        run_id = int(r.split('_')[-1])
+        if run_id >= max_id:
+            max_id = run_id + 1
+    save_dir = os.path.join(save_dir_root, 'run_cihp', 'run_' + str(max_id))
+
+    # Network definition
+    if backbone == 'xception':
+        net_ = deeplab_xception_transfer.deeplab_xception_transfer_projection_savemem(n_classes=opts.classes, os=16,
+                                                                                      hidden_layers=opts.hidden_layers, source_classes=7, )
+    elif backbone == 'resnet':
+        # net_ = deeplab_resnet.DeepLabv3_plus(nInputChannels=3, n_classes=7, os=16, pretrained=True)
+        raise NotImplementedError
+    else:
+        raise NotImplementedError
+
+    modelName = 'deeplabv3plus-' + backbone + '-voc'+datetime.now().strftime('%b%d_%H-%M-%S')
+    criterion = util.cross_entropy2d
+
+    if gpu_id >= 0:
+        # torch.cuda.set_device(device=gpu_id)
+        net_.cuda()
+
+    # net load weights
+    if not model_path == '':
+        x = torch.load(model_path)
+        net_.load_state_dict_new(x)
+        print('load pretrainedModel:', model_path)
+    else:
+        print('no pretrainedModel.')
+    if not opts.loadmodel =='':
+        x = torch.load(opts.loadmodel)
+        net_.load_source_model(x)
+        print('load model:' ,opts.loadmodel)
+    else:
+        print('no model load !!!!!!!!')
+
+    log_dir = os.path.join(save_dir, 'models', datetime.now().strftime('%b%d_%H-%M-%S') + '_' + socket.gethostname())
+    writer = SummaryWriter(log_dir=log_dir)
+    writer.add_text('load model',opts.loadmodel,1)
+    writer.add_text('setting',sys.argv[0],1)
+
+    if opts.freezeBN:
+        net_.freeze_bn()
+
+    # Use the following optimizer
+    optimizer = optim.SGD(net_.parameters(), lr=p['lr'], momentum=p['momentum'], weight_decay=p['wd'])
+
+    composed_transforms_tr = transforms.Compose([
+            tr.RandomSized_new(512),
+            tr.Normalize_xception_tf(),
+            tr.ToTensor_()])
+
+    composed_transforms_ts = transforms.Compose([
+        tr.Normalize_xception_tf(),
+        tr.ToTensor_()])
+
+    composed_transforms_ts_flip = transforms.Compose([
+        tr.HorizontalFlip(),
+        tr.Normalize_xception_tf(),
+        tr.ToTensor_()])
+
+    voc_train = cihp.VOCSegmentation(split='train', transform=composed_transforms_tr, flip=True)
+    voc_val = cihp.VOCSegmentation(split='val', transform=composed_transforms_ts)
+    voc_val_flip = cihp.VOCSegmentation(split='val', transform=composed_transforms_ts_flip)
+
+    trainloader = DataLoader(voc_train, batch_size=p['trainBatch'], shuffle=True, num_workers=p['num_workers'],drop_last=True)
+    testloader = DataLoader(voc_val, batch_size=testBatch, shuffle=False, num_workers=p['num_workers'])
+    testloader_flip = DataLoader(voc_val_flip, batch_size=testBatch, shuffle=False, num_workers=p['num_workers'])
+
+    num_img_tr = len(trainloader)
+    num_img_ts = len(testloader)
+    running_loss_tr = 0.0
+    running_loss_ts = 0.0
+    aveGrad = 0
+    global_step = 0
+    print("Training Network")
+
+    net = torch.nn.DataParallel(net_)
+    train_graph, test_graph = get_graphs(opts)
+    adj1, adj2, adj3 = train_graph
+
+
+    # Main Training and Testing Loop
+    for epoch in range(resume_epoch, nEpochs):
+        start_time = timeit.default_timer()
+
+        if epoch % p['epoch_size'] == p['epoch_size'] - 1:
+            lr_ = util.lr_poly(p['lr'], epoch, nEpochs, 0.9)
+            optimizer = optim.SGD(net_.parameters(), lr=lr_, momentum=p['momentum'], weight_decay=p['wd'])
+            writer.add_scalar('data/lr_', lr_, epoch)
+            print('(poly lr policy) learning rate: ', lr_)
+
+        net.train()
+        for ii, sample_batched in enumerate(trainloader):
+
+            inputs, labels = sample_batched['image'], sample_batched['label']
+            # Forward-Backward of the mini-batch
+            inputs, labels = Variable(inputs, requires_grad=True), Variable(labels)
+            global_step += inputs.data.shape[0]
+
+            if gpu_id >= 0:
+                inputs, labels = inputs.cuda(), labels.cuda()
+
+            outputs = net.forward(inputs, adj1, adj3, adj2)
+
+            loss = criterion(outputs, labels, batch_average=True)
+            running_loss_tr += loss.item()
+
+            # Print stuff
+            if ii % num_img_tr == (num_img_tr - 1):
+                running_loss_tr = running_loss_tr / num_img_tr
+                writer.add_scalar('data/total_loss_epoch', running_loss_tr, epoch)
+                print('[Epoch: %d, numImages: %5d]' % (epoch, ii * p['trainBatch'] + inputs.data.shape[0]))
+                print('Loss: %f' % running_loss_tr)
+                running_loss_tr = 0
+                stop_time = timeit.default_timer()
+                print("Execution time: " + str(stop_time - start_time) + "\n")
+
+            # Backward the averaged gradient
+            loss /= p['nAveGrad']
+            loss.backward()
+            aveGrad += 1
+
+            # Update the weights once in p['nAveGrad'] forward passes
+            if aveGrad % p['nAveGrad'] == 0:
+                writer.add_scalar('data/total_loss_iter', loss.item(), ii + num_img_tr * epoch)
+                optimizer.step()
+                optimizer.zero_grad()
+                aveGrad = 0
+
+            # Show 10 * 3 images results each epoch
+            if ii % (num_img_tr // 10) == 0:
+                grid_image = make_grid(inputs[:3].clone().cpu().data, 3, normalize=True)
+                writer.add_image('Image', grid_image, global_step)
+                grid_image = make_grid(util.decode_seg_map_sequence(torch.max(outputs[:3], 1)[1].detach().cpu().numpy()), 3, normalize=False,
+                                       range=(0, 255))
+                writer.add_image('Predicted label', grid_image, global_step)
+                grid_image = make_grid(util.decode_seg_map_sequence(torch.squeeze(labels[:3], 1).detach().cpu().numpy()), 3, normalize=False, range=(0, 255))
+                writer.add_image('Groundtruth label', grid_image, global_step)
+            print('loss is ', loss.cpu().item(), flush=True)
+
+        # Save the model
+        if (epoch % snapshot) == snapshot - 1:
+            torch.save(net_.state_dict(), os.path.join(save_dir, 'models', modelName + '_epoch-' + str(epoch) + '.pth'))
+            print("Save model at {}\n".format(os.path.join(save_dir, 'models', modelName + '_epoch-' + str(epoch) + '.pth')))
+
+        torch.cuda.empty_cache()
+
+        # One testing epoch
+        if useTest and epoch % nTestInterval == (nTestInterval - 1):
+            val_cihp(net_,testloader=testloader, testloader_flip=testloader_flip, test_graph=test_graph,
+                     epoch=epoch,writer=writer,criterion=criterion, classes=opts.classes)
+        torch.cuda.empty_cache()
+
+
+
+
+if __name__ == '__main__':
+    opts = get_parser()
+    main(opts)

TryYours-Virtual-Try-On/Graphonomy-master/exp/universal/pascal_atr_cihp_uni.py

@@ -0,0 +1,493 @@
+import socket
+import timeit
+from datetime import datetime
+import os
+import sys
+import glob
+import numpy as np
+from collections import OrderedDict
+sys.path.append('./')
+sys.path.append('./networks/')
+# PyTorch includes
+import torch
+from torch.autograd import Variable
+import torch.optim as optim
+from torchvision import transforms
+from torch.utils.data import DataLoader
+from torchvision.utils import make_grid
+import random
+
+# Tensorboard include
+from tensorboardX import SummaryWriter
+
+# Custom includes
+from dataloaders import pascal, cihp_pascal_atr
+from utils import get_iou_from_list
+from utils import util as ut
+from networks import deeplab_xception_universal, graph
+from dataloaders import custom_transforms as tr
+from utils import sampler as sam
+#
+import argparse
+
+'''
+source is cihp
+target is pascal
+'''
+
+gpu_id = 1
+# print('Using GPU: {} '.format(gpu_id))
+
+# nEpochs = 100  # Number of epochs for training
+resume_epoch = 0   # Default is 0, change if want to resume
+
+def flip(x, dim):
+    indices = [slice(None)] * x.dim()
+    indices[dim] = torch.arange(x.size(dim) - 1, -1, -1,
+                                dtype=torch.long, device=x.device)
+    return x[tuple(indices)]
+
+def flip_cihp(tail_list):
+    '''
+
+    :param tail_list: tail_list size is 1 x n_class x h x w
+    :return:
+    '''
+    # tail_list = tail_list[0]
+    tail_list_rev = [None] * 20
+    for xx in range(14):
+        tail_list_rev[xx] = tail_list[xx].unsqueeze(0)
+    tail_list_rev[14] = tail_list[15].unsqueeze(0)
+    tail_list_rev[15] = tail_list[14].unsqueeze(0)
+    tail_list_rev[16] = tail_list[17].unsqueeze(0)
+    tail_list_rev[17] = tail_list[16].unsqueeze(0)
+    tail_list_rev[18] = tail_list[19].unsqueeze(0)
+    tail_list_rev[19] = tail_list[18].unsqueeze(0)
+    return torch.cat(tail_list_rev,dim=0)
+
+def get_parser():
+    '''argparse begin'''
+    parser = argparse.ArgumentParser()
+    LookupChoices = type('', (argparse.Action,), dict(__call__=lambda a, p, n, v, o: setattr(n, a.dest, a.choices[v])))
+
+    parser.add_argument('--epochs', default=100, type=int)
+    parser.add_argument('--batch', default=16, type=int)
+    parser.add_argument('--lr', default=1e-7, type=float)
+    parser.add_argument('--numworker',default=12,type=int)
+    # parser.add_argument('--freezeBN', choices=dict(true=True, false=False), default=True, action=LookupChoices)
+    parser.add_argument('--step', default=10, type=int)
+    # parser.add_argument('--loadmodel',default=None,type=str)
+    parser.add_argument('--classes', default=7, type=int)
+    parser.add_argument('--testepoch', default=10, type=int)
+    parser.add_argument('--loadmodel',default='',type=str)
+    parser.add_argument('--pretrainedModel', default='', type=str)
+    parser.add_argument('--hidden_layers',default=128,type=int)
+    parser.add_argument('--gpus',default=4, type=int)
+    parser.add_argument('--testInterval', default=5, type=int)
+    opts = parser.parse_args()
+    return opts
+
+def get_graphs(opts):
+    '''source is pascal; target is cihp; middle is atr'''
+    # target 1
+    cihp_adj = graph.preprocess_adj(graph.cihp_graph)
+    adj1_ = Variable(torch.from_numpy(cihp_adj).float())
+    adj1 = adj1_.unsqueeze(0).unsqueeze(0).expand(opts.gpus, 1, 20, 20).cuda()
+    adj1_test = adj1_.unsqueeze(0).unsqueeze(0).expand(1, 1, 20, 20)
+    #source 2
+    adj2_ = Variable(torch.from_numpy(graph.preprocess_adj(graph.pascal_graph)).float())
+    adj2 = adj2_.unsqueeze(0).unsqueeze(0).expand(opts.gpus, 1, 7, 7).cuda()
+    adj2_test = adj2_.unsqueeze(0).unsqueeze(0).expand(1, 1, 7, 7)
+    # s to target 3
+    adj3_ = torch.from_numpy(graph.cihp2pascal_nlp_adj).float()
+    adj3 = adj3_.unsqueeze(0).unsqueeze(0).expand(opts.gpus, 1, 7, 20).transpose(2,3).cuda()
+    adj3_test = adj3_.unsqueeze(0).unsqueeze(0).expand(1, 1, 7, 20).transpose(2,3)
+    # middle 4
+    atr_adj = graph.preprocess_adj(graph.atr_graph)
+    adj4_ = Variable(torch.from_numpy(atr_adj).float())
+    adj4 = adj4_.unsqueeze(0).unsqueeze(0).expand(opts.gpus, 1, 18, 18).cuda()
+    adj4_test = adj4_.unsqueeze(0).unsqueeze(0).expand(1, 1, 18, 18)
+    # source to middle 5
+    adj5_ = torch.from_numpy(graph.pascal2atr_nlp_adj).float()
+    adj5 = adj5_.unsqueeze(0).unsqueeze(0).expand(opts.gpus, 1, 7, 18).cuda()
+    adj5_test = adj5_.unsqueeze(0).unsqueeze(0).expand(1, 1, 7, 18)
+    # target to middle 6
+    adj6_ = torch.from_numpy(graph.cihp2atr_nlp_adj).float()
+    adj6 = adj6_.unsqueeze(0).unsqueeze(0).expand(opts.gpus, 1, 20, 18).cuda()
+    adj6_test = adj6_.unsqueeze(0).unsqueeze(0).expand(1, 1, 20, 18)
+    train_graph = [adj1, adj2, adj3, adj4, adj5, adj6]
+    test_graph = [adj1_test, adj2_test, adj3_test, adj4_test, adj5_test, adj6_test]
+    return train_graph, test_graph
+
+
+def main(opts):
+    # Set parameters
+    p = OrderedDict()  # Parameters to include in report
+    p['trainBatch'] = opts.batch  # Training batch size
+    testBatch = 1  # Testing batch size
+    useTest = True  # See evolution of the test set when training
+    nTestInterval = opts.testInterval # Run on test set every nTestInterval epochs
+    snapshot = 1  # Store a model every snapshot epochs
+    p['nAveGrad'] = 1  # Average the gradient of several iterations
+    p['lr'] = opts.lr  # Learning rate
+    p['wd'] = 5e-4  # Weight decay
+    p['momentum'] = 0.9  # Momentum
+    p['epoch_size'] = opts.step  # How many epochs to change learning rate
+    p['num_workers'] = opts.numworker
+    model_path = opts.pretrainedModel
+    backbone = 'xception' # Use xception or resnet as feature extractor
+    nEpochs = opts.epochs
+
+    max_id = 0
+    save_dir_root = os.path.join(os.path.dirname(os.path.abspath(__file__)))
+    exp_name = os.path.dirname(os.path.abspath(__file__)).split('/')[-1]
+    runs = glob.glob(os.path.join(save_dir_root, 'run', 'run_*'))
+    for r in runs:
+        run_id = int(r.split('_')[-1])
+        if run_id >= max_id:
+            max_id = run_id + 1
+    # run_id = int(runs[-1].split('_')[-1]) + 1 if runs else 0
+    save_dir = os.path.join(save_dir_root, 'run', 'run_' + str(max_id))
+
+    # Network definition
+    if backbone == 'xception':
+        net_ = deeplab_xception_universal.deeplab_xception_end2end_3d(n_classes=20, os=16,
+                                                                      hidden_layers=opts.hidden_layers,
+                                                                      source_classes=7,
+                                                                      middle_classes=18, )
+    elif backbone == 'resnet':
+        # net_ = deeplab_resnet.DeepLabv3_plus(nInputChannels=3, n_classes=7, os=16, pretrained=True)
+        raise NotImplementedError
+    else:
+        raise NotImplementedError
+
+    modelName = 'deeplabv3plus-' + backbone + '-voc'+datetime.now().strftime('%b%d_%H-%M-%S')
+    criterion = ut.cross_entropy2d
+
+    if gpu_id >= 0:
+        # torch.cuda.set_device(device=gpu_id)
+        net_.cuda()
+
+    # net load weights
+    if not model_path == '':
+        x = torch.load(model_path)
+        net_.load_state_dict_new(x)
+        print('load pretrainedModel.')
+    else:
+        print('no pretrainedModel.')
+
+    if not opts.loadmodel =='':
+        x = torch.load(opts.loadmodel)
+        net_.load_source_model(x)
+        print('load model:' ,opts.loadmodel)
+    else:
+        print('no trained model load !!!!!!!!')
+
+    log_dir = os.path.join(save_dir, 'models', datetime.now().strftime('%b%d_%H-%M-%S') + '_' + socket.gethostname())
+    writer = SummaryWriter(log_dir=log_dir)
+    writer.add_text('load model',opts.loadmodel,1)
+    writer.add_text('setting',sys.argv[0],1)
+
+    # Use the following optimizer
+    optimizer = optim.SGD(net_.parameters(), lr=p['lr'], momentum=p['momentum'], weight_decay=p['wd'])
+
+    composed_transforms_tr = transforms.Compose([
+            tr.RandomSized_new(512),
+            tr.Normalize_xception_tf(),
+            tr.ToTensor_()])
+
+    composed_transforms_ts = transforms.Compose([
+        tr.Normalize_xception_tf(),
+        tr.ToTensor_()])
+
+    composed_transforms_ts_flip = transforms.Compose([
+        tr.HorizontalFlip(),
+        tr.Normalize_xception_tf(),
+        tr.ToTensor_()])
+
+    all_train = cihp_pascal_atr.VOCSegmentation(split='train', transform=composed_transforms_tr, flip=True)
+    voc_val = pascal.VOCSegmentation(split='val', transform=composed_transforms_ts)
+    voc_val_flip = pascal.VOCSegmentation(split='val', transform=composed_transforms_ts_flip)
+
+    num_cihp,num_pascal,num_atr = all_train.get_class_num()
+    ss = sam.Sampler_uni(num_cihp,num_pascal,num_atr,opts.batch)
+    # balance datasets based pascal
+    ss_balanced = sam.Sampler_uni(num_cihp,num_pascal,num_atr,opts.batch, balance_id=1)
+
+    trainloader = DataLoader(all_train, batch_size=p['trainBatch'], shuffle=False, num_workers=p['num_workers'],
+                             sampler=ss, drop_last=True)
+    trainloader_balanced = DataLoader(all_train, batch_size=p['trainBatch'], shuffle=False, num_workers=p['num_workers'],
+                             sampler=ss_balanced, drop_last=True)
+    testloader = DataLoader(voc_val, batch_size=testBatch, shuffle=False, num_workers=p['num_workers'])
+    testloader_flip = DataLoader(voc_val_flip, batch_size=testBatch, shuffle=False, num_workers=p['num_workers'])
+
+    num_img_tr = len(trainloader)
+    num_img_balanced = len(trainloader_balanced)
+    num_img_ts = len(testloader)
+    running_loss_tr = 0.0
+    running_loss_tr_atr = 0.0
+    running_loss_ts = 0.0
+    aveGrad = 0
+    global_step = 0
+    print("Training Network")
+    net = torch.nn.DataParallel(net_)
+
+    id_list = torch.LongTensor(range(opts.batch))
+    pascal_iter = int(num_img_tr//opts.batch)
+
+    # Get graphs
+    train_graph, test_graph = get_graphs(opts)
+    adj1, adj2, adj3, adj4, adj5, adj6 = train_graph
+    adj1_test, adj2_test, adj3_test, adj4_test, adj5_test, adj6_test = test_graph
+
+    # Main Training and Testing Loop
+    for epoch in range(resume_epoch, int(1.5*nEpochs)):
+        start_time = timeit.default_timer()
+
+        if epoch % p['epoch_size'] == p['epoch_size'] - 1 and epoch<nEpochs:
+            lr_ = ut.lr_poly(p['lr'], epoch, nEpochs, 0.9)
+            optimizer = optim.SGD(net_.parameters(), lr=lr_, momentum=p['momentum'], weight_decay=p['wd'])
+            print('(poly lr policy) learning rate: ', lr_)
+            writer.add_scalar('data/lr_',lr_,epoch)
+        elif epoch % p['epoch_size'] == p['epoch_size'] - 1 and epoch > nEpochs:
+            lr_ = ut.lr_poly(p['lr'], epoch-nEpochs, int(0.5*nEpochs), 0.9)
+            optimizer = optim.SGD(net_.parameters(), lr=lr_, momentum=p['momentum'], weight_decay=p['wd'])
+            print('(poly lr policy) learning rate: ', lr_)
+            writer.add_scalar('data/lr_', lr_, epoch)
+
+        net_.train()
+        if epoch < nEpochs:
+            for ii, sample_batched in enumerate(trainloader):
+                inputs, labels = sample_batched['image'], sample_batched['label']
+                dataset_lbl = sample_batched['pascal'][0].item()
+                # Forward-Backward of the mini-batch
+                inputs, labels = Variable(inputs, requires_grad=True), Variable(labels)
+                global_step += 1
+
+                if gpu_id >= 0:
+                    inputs, labels = inputs.cuda(), labels.cuda()
+
+                if dataset_lbl == 0:
+                    # 0 is cihp -- target
+                    _, outputs,_ = net.forward(None, input_target=inputs, input_middle=None, adj1_target=adj1, adj2_source=adj2,
+                        adj3_transfer_s2t=adj3, adj3_transfer_t2s=adj3.transpose(2,3), adj4_middle=adj4,adj5_transfer_s2m=adj5.transpose(2, 3),
+                        adj6_transfer_t2m=adj6.transpose(2, 3),adj5_transfer_m2s=adj5,adj6_transfer_m2t=adj6,)
+                elif dataset_lbl == 1:
+                    # pascal is source
+                    outputs, _, _ = net.forward(inputs, input_target=None, input_middle=None, adj1_target=adj1,
+                                                adj2_source=adj2,
+                                                adj3_transfer_s2t=adj3, adj3_transfer_t2s=adj3.transpose(2, 3),
+                                                adj4_middle=adj4, adj5_transfer_s2m=adj5.transpose(2, 3),
+                                                adj6_transfer_t2m=adj6.transpose(2, 3), adj5_transfer_m2s=adj5,
+                                                adj6_transfer_m2t=adj6, )
+                else:
+                    # atr
+                    _, _, outputs = net.forward(None, input_target=None, input_middle=inputs, adj1_target=adj1,
+                                                adj2_source=adj2,
+                                                adj3_transfer_s2t=adj3, adj3_transfer_t2s=adj3.transpose(2, 3),
+                                                adj4_middle=adj4, adj5_transfer_s2m=adj5.transpose(2, 3),
+                                                adj6_transfer_t2m=adj6.transpose(2, 3), adj5_transfer_m2s=adj5,
+                                                adj6_transfer_m2t=adj6, )
+                # print(sample_batched['pascal'])
+                # print(outputs.size(),)
+                # print(labels)
+                loss = criterion(outputs, labels,  batch_average=True)
+                running_loss_tr += loss.item()
+
+                # Print stuff
+                if ii % num_img_tr == (num_img_tr - 1):
+                    running_loss_tr = running_loss_tr / num_img_tr
+                    writer.add_scalar('data/total_loss_epoch', running_loss_tr, epoch)
+                    print('[Epoch: %d, numImages: %5d]' % (epoch, epoch))
+                    print('Loss: %f' % running_loss_tr)
+                    running_loss_tr = 0
+                    stop_time = timeit.default_timer()
+                    print("Execution time: " + str(stop_time - start_time) + "\n")
+
+                # Backward the averaged gradient
+                loss /= p['nAveGrad']
+                loss.backward()
+                aveGrad += 1
+
+                # Update the weights once in p['nAveGrad'] forward passes
+                if aveGrad % p['nAveGrad'] == 0:
+                    writer.add_scalar('data/total_loss_iter', loss.item(), global_step)
+                    if dataset_lbl == 0:
+                        writer.add_scalar('data/total_loss_iter_cihp', loss.item(), global_step)
+                    if dataset_lbl == 1:
+                        writer.add_scalar('data/total_loss_iter_pascal', loss.item(), global_step)
+                    if dataset_lbl == 2:
+                        writer.add_scalar('data/total_loss_iter_atr', loss.item(), global_step)
+                    optimizer.step()
+                    optimizer.zero_grad()
+                    # optimizer_gcn.step()
+                    # optimizer_gcn.zero_grad()
+                    aveGrad = 0
+
+                # Show 10 * 3 images results each epoch
+                if ii % (num_img_tr // 10) == 0:
+                    grid_image = make_grid(inputs[:3].clone().cpu().data, 3, normalize=True)
+                    writer.add_image('Image', grid_image, global_step)
+                    grid_image = make_grid(ut.decode_seg_map_sequence(torch.max(outputs[:3], 1)[1].detach().cpu().numpy()), 3, normalize=False,
+                                           range=(0, 255))
+                    writer.add_image('Predicted label', grid_image, global_step)
+                    grid_image = make_grid(ut.decode_seg_map_sequence(torch.squeeze(labels[:3], 1).detach().cpu().numpy()), 3, normalize=False, range=(0, 255))
+                    writer.add_image('Groundtruth label', grid_image, global_step)
+
+                print('loss is ',loss.cpu().item(),flush=True)
+        else:
+            # Balanced the number of datasets
+            for ii, sample_batched in enumerate(trainloader_balanced):
+                inputs, labels = sample_batched['image'], sample_batched['label']
+                dataset_lbl = sample_batched['pascal'][0].item()
+                # Forward-Backward of the mini-batch
+                inputs, labels = Variable(inputs, requires_grad=True), Variable(labels)
+                global_step += 1
+
+                if gpu_id >= 0:
+                    inputs, labels = inputs.cuda(), labels.cuda()
+
+                if dataset_lbl == 0:
+                    # 0 is cihp -- target
+                    _, outputs, _ = net.forward(None, input_target=inputs, input_middle=None, adj1_target=adj1,
+                                                adj2_source=adj2,
+                                                adj3_transfer_s2t=adj3, adj3_transfer_t2s=adj3.transpose(2, 3),
+                                                adj4_middle=adj4, adj5_transfer_s2m=adj5.transpose(2, 3),
+                                                adj6_transfer_t2m=adj6.transpose(2, 3), adj5_transfer_m2s=adj5,
+                                                adj6_transfer_m2t=adj6, )
+                elif dataset_lbl == 1:
+                    # pascal is source
+                    outputs, _, _ = net.forward(inputs, input_target=None, input_middle=None, adj1_target=adj1,
+                                                adj2_source=adj2,
+                                                adj3_transfer_s2t=adj3, adj3_transfer_t2s=adj3.transpose(2, 3),
+                                                adj4_middle=adj4, adj5_transfer_s2m=adj5.transpose(2, 3),
+                                                adj6_transfer_t2m=adj6.transpose(2, 3), adj5_transfer_m2s=adj5,
+                                                adj6_transfer_m2t=adj6, )
+                else:
+                    # atr
+                    _, _, outputs = net.forward(None, input_target=None, input_middle=inputs, adj1_target=adj1,
+                                                adj2_source=adj2,
+                                                adj3_transfer_s2t=adj3, adj3_transfer_t2s=adj3.transpose(2, 3),
+                                                adj4_middle=adj4, adj5_transfer_s2m=adj5.transpose(2, 3),
+                                                adj6_transfer_t2m=adj6.transpose(2, 3), adj5_transfer_m2s=adj5,
+                                                adj6_transfer_m2t=adj6, )
+                # print(sample_batched['pascal'])
+                # print(outputs.size(),)
+                # print(labels)
+                loss = criterion(outputs, labels, batch_average=True)
+                running_loss_tr += loss.item()
+
+                # Print stuff
+                if ii % num_img_balanced == (num_img_balanced - 1):
+                    running_loss_tr = running_loss_tr / num_img_balanced
+                    writer.add_scalar('data/total_loss_epoch', running_loss_tr, epoch)
+                    print('[Epoch: %d, numImages: %5d]' % (epoch, epoch))
+                    print('Loss: %f' % running_loss_tr)
+                    running_loss_tr = 0
+                    stop_time = timeit.default_timer()
+                    print("Execution time: " + str(stop_time - start_time) + "\n")
+
+                # Backward the averaged gradient
+                loss /= p['nAveGrad']
+                loss.backward()
+                aveGrad += 1
+
+                # Update the weights once in p['nAveGrad'] forward passes
+                if aveGrad % p['nAveGrad'] == 0:
+                    writer.add_scalar('data/total_loss_iter', loss.item(), global_step)
+                    if dataset_lbl == 0:
+                        writer.add_scalar('data/total_loss_iter_cihp', loss.item(), global_step)
+                    if dataset_lbl == 1:
+                        writer.add_scalar('data/total_loss_iter_pascal', loss.item(), global_step)
+                    if dataset_lbl == 2:
+                        writer.add_scalar('data/total_loss_iter_atr', loss.item(), global_step)
+                    optimizer.step()
+                    optimizer.zero_grad()
+
+                    aveGrad = 0
+
+                # Show 10 * 3 images results each epoch
+                if ii % (num_img_balanced // 10) == 0:
+                    grid_image = make_grid(inputs[:3].clone().cpu().data, 3, normalize=True)
+                    writer.add_image('Image', grid_image, global_step)
+                    grid_image = make_grid(
+                        ut.decode_seg_map_sequence(torch.max(outputs[:3], 1)[1].detach().cpu().numpy()), 3,
+                        normalize=False,
+                        range=(0, 255))
+                    writer.add_image('Predicted label', grid_image, global_step)
+                    grid_image = make_grid(
+                        ut.decode_seg_map_sequence(torch.squeeze(labels[:3], 1).detach().cpu().numpy()), 3,
+                        normalize=False, range=(0, 255))
+                    writer.add_image('Groundtruth label', grid_image, global_step)
+
+                print('loss is ', loss.cpu().item(), flush=True)
+
+        # Save the model
+        if (epoch % snapshot) == snapshot - 1:
+            torch.save(net_.state_dict(), os.path.join(save_dir, 'models', modelName + '_epoch-' + str(epoch) + '.pth'))
+            print("Save model at {}\n".format(os.path.join(save_dir, 'models', modelName + '_epoch-' + str(epoch) + '.pth')))
+
+        # One testing epoch
+        if useTest and epoch % nTestInterval == (nTestInterval - 1):
+            val_pascal(net_=net_, testloader=testloader, testloader_flip=testloader_flip, test_graph=test_graph,
+                       criterion=criterion, epoch=epoch, writer=writer)
+
+
+def val_pascal(net_, testloader, testloader_flip, test_graph, criterion, epoch, writer, classes=7):
+    running_loss_ts = 0.0
+    miou = 0
+    adj1_test, adj2_test, adj3_test, adj4_test, adj5_test, adj6_test = test_graph
+    num_img_ts = len(testloader)
+    net_.eval()
+    pred_list = []
+    label_list = []
+    for ii, sample_batched in enumerate(zip(testloader, testloader_flip)):
+        # print(ii)
+        inputs, labels = sample_batched[0]['image'], sample_batched[0]['label']
+        inputs_f, _ = sample_batched[1]['image'], sample_batched[1]['label']
+        inputs = torch.cat((inputs, inputs_f), dim=0)
+        # Forward pass of the mini-batch
+        inputs, labels = Variable(inputs, requires_grad=False), Variable(labels)
+
+        with torch.no_grad():
+            if gpu_id >= 0:
+                inputs, labels = inputs.cuda(), labels.cuda()
+            outputs, _, _ = net_.forward(inputs, input_target=None, input_middle=None,
+                                         adj1_target=adj1_test.cuda(),
+                                         adj2_source=adj2_test.cuda(),
+                                         adj3_transfer_s2t=adj3_test.cuda(),
+                                         adj3_transfer_t2s=adj3_test.transpose(2, 3).cuda(),
+                                         adj4_middle=adj4_test.cuda(),
+                                         adj5_transfer_s2m=adj5_test.transpose(2, 3).cuda(),
+                                         adj6_transfer_t2m=adj6_test.transpose(2, 3).cuda(),
+                                         adj5_transfer_m2s=adj5_test.cuda(),
+                                         adj6_transfer_m2t=adj6_test.cuda(), )
+        # pdb.set_trace()
+        outputs = (outputs[0] + flip(outputs[1], dim=-1)) / 2
+        outputs = outputs.unsqueeze(0)
+        predictions = torch.max(outputs, 1)[1]
+        pred_list.append(predictions.cpu())
+        label_list.append(labels.squeeze(1).cpu())
+        loss = criterion(outputs, labels, batch_average=True)
+        running_loss_ts += loss.item()
+
+        # total_iou += utils.get_iou(predictions, labels)
+
+        # Print stuff
+        if ii % num_img_ts == num_img_ts - 1:
+            # if ii == 10:
+            miou = get_iou_from_list(pred_list, label_list, n_cls=classes)
+            running_loss_ts = running_loss_ts / num_img_ts
+
+            print('Validation:')
+            print('[Epoch: %d, numImages: %5d]' % (epoch, ii * 1 + inputs.data.shape[0]))
+            writer.add_scalar('data/test_loss_epoch', running_loss_ts, epoch)
+            writer.add_scalar('data/test_miour', miou, epoch)
+            print('Loss: %f' % running_loss_ts)
+            print('MIoU: %f\n' % miou)
+    # return miou
+
+
+if __name__ == '__main__':
+    opts = get_parser()
+    main(opts)

TryYours-Virtual-Try-On/Graphonomy-master/inference.sh

@@ -0,0 +1 @@
+python exp/inference/inference.py --loadmodel ./data/pretrained_model/inference.pth --img_path ./img/messi.jpg --output_path ./img/ --output_name /output_file_name

TryYours-Virtual-Try-On/Graphonomy-master/networks/__init__.py

@@ -0,0 +1,3 @@
+from .deeplab_xception import *
+from .deeplab_xception_transfer import *
+from .deeplab_xception_universal import *

TryYours-Virtual-Try-On/Graphonomy-master/networks/deeplab_xception.py

@@ -0,0 +1,684 @@
+import math
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.utils.model_zoo as model_zoo
+from torch.nn.parameter import Parameter
+from collections import OrderedDict
+
+class SeparableConv2d(nn.Module):
+    def __init__(self, inplanes, planes, kernel_size=3, stride=1, padding=0, dilation=1, bias=False):
+        super(SeparableConv2d, self).__init__()
+
+        self.conv1 = nn.Conv2d(inplanes, inplanes, kernel_size, stride, padding, dilation,
+                               groups=inplanes, bias=bias)
+        self.pointwise = nn.Conv2d(inplanes, planes, 1, 1, 0, 1, 1, bias=bias)
+
+    def forward(self, x):
+        x = self.conv1(x)
+        x = self.pointwise(x)
+        return x
+
+
+def fixed_padding(inputs, kernel_size, rate):
+    kernel_size_effective = kernel_size + (kernel_size - 1) * (rate - 1)
+    pad_total = kernel_size_effective - 1
+    pad_beg = pad_total // 2
+    pad_end = pad_total - pad_beg
+    padded_inputs = F.pad(inputs, (pad_beg, pad_end, pad_beg, pad_end))
+    return padded_inputs
+
+
+class SeparableConv2d_aspp(nn.Module):
+    def __init__(self, inplanes, planes, kernel_size=3, stride=1, dilation=1, bias=False, padding=0):
+        super(SeparableConv2d_aspp, self).__init__()
+
+        self.depthwise = nn.Conv2d(inplanes, inplanes, kernel_size, stride, padding, dilation,
+                                   groups=inplanes, bias=bias)
+        self.depthwise_bn = nn.BatchNorm2d(inplanes)
+        self.pointwise = nn.Conv2d(inplanes, planes, 1, 1, 0, 1, 1, bias=bias)
+        self.pointwise_bn = nn.BatchNorm2d(planes)
+        self.relu = nn.ReLU()
+
+    def forward(self, x):
+        #         x = fixed_padding(x, self.depthwise.kernel_size[0], rate=self.depthwise.dilation[0])
+        x = self.depthwise(x)
+        x = self.depthwise_bn(x)
+        x = self.relu(x)
+        x = self.pointwise(x)
+        x = self.pointwise_bn(x)
+        x = self.relu(x)
+        return x
+
+class Decoder_module(nn.Module):
+    def __init__(self, inplanes, planes, rate=1):
+        super(Decoder_module, self).__init__()
+        self.atrous_convolution = SeparableConv2d_aspp(inplanes, planes, 3, stride=1, dilation=rate,padding=1)
+
+    def forward(self, x):
+        x = self.atrous_convolution(x)
+        return x
+
+class ASPP_module(nn.Module):
+    def __init__(self, inplanes, planes, rate):
+        super(ASPP_module, self).__init__()
+        if rate == 1:
+            raise RuntimeError()
+        else:
+            kernel_size = 3
+            padding = rate
+            self.atrous_convolution = SeparableConv2d_aspp(inplanes, planes, 3, stride=1, dilation=rate,
+                                                           padding=padding)
+
+    def forward(self, x):
+        x = self.atrous_convolution(x)
+        return x
+
+class ASPP_module_rate0(nn.Module):
+    def __init__(self, inplanes, planes, rate=1):
+        super(ASPP_module_rate0, self).__init__()
+        if rate == 1:
+            kernel_size = 1
+            padding = 0
+            self.atrous_convolution = nn.Conv2d(inplanes, planes, kernel_size=kernel_size,
+                                                stride=1, padding=padding, dilation=rate, bias=False)
+            self.bn = nn.BatchNorm2d(planes, eps=1e-5, affine=True)
+            self.relu = nn.ReLU()
+        else:
+            raise RuntimeError()
+
+    def forward(self, x):
+        x = self.atrous_convolution(x)
+        x = self.bn(x)
+        return self.relu(x)
+
+class SeparableConv2d_same(nn.Module):
+    def __init__(self, inplanes, planes, kernel_size=3, stride=1, dilation=1, bias=False, padding=0):
+        super(SeparableConv2d_same, self).__init__()
+
+        self.depthwise = nn.Conv2d(inplanes, inplanes, kernel_size, stride, padding, dilation,
+                                   groups=inplanes, bias=bias)
+        self.depthwise_bn = nn.BatchNorm2d(inplanes)
+        self.pointwise = nn.Conv2d(inplanes, planes, 1, 1, 0, 1, 1, bias=bias)
+        self.pointwise_bn = nn.BatchNorm2d(planes)
+
+    def forward(self, x):
+        x = fixed_padding(x, self.depthwise.kernel_size[0], rate=self.depthwise.dilation[0])
+        x = self.depthwise(x)
+        x = self.depthwise_bn(x)
+        x = self.pointwise(x)
+        x = self.pointwise_bn(x)
+        return x
+
+class Block(nn.Module):
+    def __init__(self, inplanes, planes, reps, stride=1, dilation=1, start_with_relu=True, grow_first=True, is_last=False):
+        super(Block, self).__init__()
+
+        if planes != inplanes or stride != 1:
+            self.skip = nn.Conv2d(inplanes, planes, 1, stride=2, bias=False)
+            if is_last:
+                self.skip = nn.Conv2d(inplanes, planes, 1, stride=1, bias=False)
+            self.skipbn = nn.BatchNorm2d(planes)
+        else:
+            self.skip = None
+
+        self.relu = nn.ReLU(inplace=True)
+        rep = []
+
+        filters = inplanes
+        if grow_first:
+            rep.append(self.relu)
+            rep.append(SeparableConv2d_same(inplanes, planes, 3, stride=1, dilation=dilation))
+#             rep.append(nn.BatchNorm2d(planes))
+            filters = planes
+
+        for i in range(reps - 1):
+            rep.append(self.relu)
+            rep.append(SeparableConv2d_same(filters, filters, 3, stride=1, dilation=dilation))
+#             rep.append(nn.BatchNorm2d(filters))
+
+        if not grow_first:
+            rep.append(self.relu)
+            rep.append(SeparableConv2d_same(inplanes, planes, 3, stride=1, dilation=dilation))
+#             rep.append(nn.BatchNorm2d(planes))
+
+        if not start_with_relu:
+            rep = rep[1:]
+
+        if stride != 1:
+            rep.append(self.relu)
+            rep.append(SeparableConv2d_same(planes, planes, 3, stride=2,dilation=dilation))
+
+        if is_last:
+            rep.append(self.relu)
+            rep.append(SeparableConv2d_same(planes, planes, 3, stride=1,dilation=dilation))
+
+
+        self.rep = nn.Sequential(*rep)
+
+    def forward(self, inp):
+        x = self.rep(inp)
+
+        if self.skip is not None:
+            skip = self.skip(inp)
+            skip = self.skipbn(skip)
+        else:
+            skip = inp
+        # print(x.size(),skip.size())
+        x += skip
+
+        return x
+
+class Block2(nn.Module):
+    def __init__(self, inplanes, planes, reps, stride=1, dilation=1, start_with_relu=True, grow_first=True, is_last=False):
+        super(Block2, self).__init__()
+
+        if planes != inplanes or stride != 1:
+            self.skip = nn.Conv2d(inplanes, planes, 1, stride=stride, bias=False)
+            self.skipbn = nn.BatchNorm2d(planes)
+        else:
+            self.skip = None
+
+        self.relu = nn.ReLU(inplace=True)
+        rep = []
+
+        filters = inplanes
+        if grow_first:
+            rep.append(self.relu)
+            rep.append(SeparableConv2d_same(inplanes, planes, 3, stride=1, dilation=dilation))
+#             rep.append(nn.BatchNorm2d(planes))
+            filters = planes
+
+        for i in range(reps - 1):
+            rep.append(self.relu)
+            rep.append(SeparableConv2d_same(filters, filters, 3, stride=1, dilation=dilation))
+#             rep.append(nn.BatchNorm2d(filters))
+
+        if not grow_first:
+            rep.append(self.relu)
+            rep.append(SeparableConv2d_same(inplanes, planes, 3, stride=1, dilation=dilation))
+#             rep.append(nn.BatchNorm2d(planes))
+
+        if not start_with_relu:
+            rep = rep[1:]
+
+        if stride != 1:
+            self.block2_lastconv = nn.Sequential(*[self.relu,SeparableConv2d_same(planes, planes, 3, stride=2,dilation=dilation)])
+
+        if is_last:
+            rep.append(SeparableConv2d_same(planes, planes, 3, stride=1))
+
+
+        self.rep = nn.Sequential(*rep)
+
+    def forward(self, inp):
+        x = self.rep(inp)
+        low_middle = x.clone()
+        x1 = x
+        x1 = self.block2_lastconv(x1)
+        if self.skip is not None:
+            skip = self.skip(inp)
+            skip = self.skipbn(skip)
+        else:
+            skip = inp
+
+        x1 += skip
+
+        return x1,low_middle
+
+class Xception(nn.Module):
+    """
+    Modified Alighed Xception
+    """
+    def __init__(self, inplanes=3, os=16, pretrained=False):
+        super(Xception, self).__init__()
+
+        if os == 16:
+            entry_block3_stride = 2
+            middle_block_rate = 1
+            exit_block_rates = (1, 2)
+        elif os == 8:
+            entry_block3_stride = 1
+            middle_block_rate = 2
+            exit_block_rates = (2, 4)
+        else:
+            raise NotImplementedError
+
+
+        # Entry flow
+        self.conv1 = nn.Conv2d(inplanes, 32, 3, stride=2, padding=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(32)
+        self.relu = nn.ReLU(inplace=True)
+
+        self.conv2 = nn.Conv2d(32, 64, 3, stride=1, padding=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(64)
+
+        self.block1 = Block(64, 128, reps=2, stride=2, start_with_relu=False)
+        self.block2 = Block2(128, 256, reps=2, stride=2, start_with_relu=True, grow_first=True)
+        self.block3 = Block(256, 728, reps=2, stride=entry_block3_stride, start_with_relu=True, grow_first=True)
+
+        # Middle flow
+        self.block4  = Block(728, 728, reps=3, stride=1, dilation=middle_block_rate, start_with_relu=True, grow_first=True)
+        self.block5  = Block(728, 728, reps=3, stride=1, dilation=middle_block_rate, start_with_relu=True, grow_first=True)
+        self.block6  = Block(728, 728, reps=3, stride=1, dilation=middle_block_rate, start_with_relu=True, grow_first=True)
+        self.block7  = Block(728, 728, reps=3, stride=1, dilation=middle_block_rate, start_with_relu=True, grow_first=True)
+        self.block8  = Block(728, 728, reps=3, stride=1, dilation=middle_block_rate, start_with_relu=True, grow_first=True)
+        self.block9  = Block(728, 728, reps=3, stride=1, dilation=middle_block_rate, start_with_relu=True, grow_first=True)
+        self.block10 = Block(728, 728, reps=3, stride=1, dilation=middle_block_rate, start_with_relu=True, grow_first=True)
+        self.block11 = Block(728, 728, reps=3, stride=1, dilation=middle_block_rate, start_with_relu=True, grow_first=True)
+        self.block12 = Block(728, 728, reps=3, stride=1, dilation=middle_block_rate, start_with_relu=True, grow_first=True)
+        self.block13 = Block(728, 728, reps=3, stride=1, dilation=middle_block_rate, start_with_relu=True, grow_first=True)
+        self.block14 = Block(728, 728, reps=3, stride=1, dilation=middle_block_rate, start_with_relu=True, grow_first=True)
+        self.block15 = Block(728, 728, reps=3, stride=1, dilation=middle_block_rate, start_with_relu=True, grow_first=True)
+        self.block16 = Block(728, 728, reps=3, stride=1, dilation=middle_block_rate, start_with_relu=True, grow_first=True)
+        self.block17 = Block(728, 728, reps=3, stride=1, dilation=middle_block_rate, start_with_relu=True, grow_first=True)
+        self.block18 = Block(728, 728, reps=3, stride=1, dilation=middle_block_rate, start_with_relu=True, grow_first=True)
+        self.block19 = Block(728, 728, reps=3, stride=1, dilation=middle_block_rate, start_with_relu=True, grow_first=True)
+
+        # Exit flow
+        self.block20 = Block(728, 1024, reps=2, stride=1, dilation=exit_block_rates[0],
+                             start_with_relu=True, grow_first=False, is_last=True)
+
+        self.conv3 = SeparableConv2d_aspp(1024, 1536, 3, stride=1, dilation=exit_block_rates[1],padding=exit_block_rates[1])
+        # self.bn3 = nn.BatchNorm2d(1536)
+
+        self.conv4 = SeparableConv2d_aspp(1536, 1536, 3, stride=1, dilation=exit_block_rates[1],padding=exit_block_rates[1])
+        # self.bn4 = nn.BatchNorm2d(1536)
+
+        self.conv5 = SeparableConv2d_aspp(1536, 2048, 3, stride=1, dilation=exit_block_rates[1],padding=exit_block_rates[1])
+        # self.bn5 = nn.BatchNorm2d(2048)
+
+        # Init weights
+        # self.__init_weight()
+
+        # Load pretrained model
+        if pretrained:
+            self.__load_xception_pretrained()
+
+    def forward(self, x):
+        # Entry flow
+        x = self.conv1(x)
+        x = self.bn1(x)
+        x = self.relu(x)
+        # print('conv1 ',x.size())
+        x = self.conv2(x)
+        x = self.bn2(x)
+        x = self.relu(x)
+
+        x = self.block1(x)
+        # print('block1',x.size())
+        # low_level_feat = x
+        x,low_level_feat = self.block2(x)
+        # print('block2',x.size())
+        x = self.block3(x)
+        # print('xception block3 ',x.size())
+
+        # Middle flow
+        x = self.block4(x)
+        x = self.block5(x)
+        x = self.block6(x)
+        x = self.block7(x)
+        x = self.block8(x)
+        x = self.block9(x)
+        x = self.block10(x)
+        x = self.block11(x)
+        x = self.block12(x)
+        x = self.block13(x)
+        x = self.block14(x)
+        x = self.block15(x)
+        x = self.block16(x)
+        x = self.block17(x)
+        x = self.block18(x)
+        x = self.block19(x)
+
+        # Exit flow
+        x = self.block20(x)
+        x = self.conv3(x)
+        # x = self.bn3(x)
+        x = self.relu(x)
+
+        x = self.conv4(x)
+        # x = self.bn4(x)
+        x = self.relu(x)
+
+        x = self.conv5(x)
+        # x = self.bn5(x)
+        x = self.relu(x)
+
+        return x, low_level_feat
+
+    def __init_weight(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                # n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
+                # m.weight.data.normal_(0, math.sqrt(2. / n))
+                torch.nn.init.kaiming_normal_(m.weight)
+            elif isinstance(m, nn.BatchNorm2d):
+                m.weight.data.fill_(1)
+                m.bias.data.zero_()
+
+    def __load_xception_pretrained(self):
+        pretrain_dict = model_zoo.load_url('http://data.lip6.fr/cadene/pretrainedmodels/xception-b5690688.pth')
+        model_dict = {}
+        state_dict = self.state_dict()
+
+        for k, v in pretrain_dict.items():
+            if k in state_dict:
+                if 'pointwise' in k:
+                    v = v.unsqueeze(-1).unsqueeze(-1)
+                if k.startswith('block12'):
+                    model_dict[k.replace('block12', 'block20')] = v
+                elif k.startswith('block11'):
+                    model_dict[k.replace('block11', 'block12')] = v
+                    model_dict[k.replace('block11', 'block13')] = v
+                    model_dict[k.replace('block11', 'block14')] = v
+                    model_dict[k.replace('block11', 'block15')] = v
+                    model_dict[k.replace('block11', 'block16')] = v
+                    model_dict[k.replace('block11', 'block17')] = v
+                    model_dict[k.replace('block11', 'block18')] = v
+                    model_dict[k.replace('block11', 'block19')] = v
+                elif k.startswith('conv3'):
+                    model_dict[k] = v
+                elif k.startswith('bn3'):
+                    model_dict[k] = v
+                    model_dict[k.replace('bn3', 'bn4')] = v
+                elif k.startswith('conv4'):
+                    model_dict[k.replace('conv4', 'conv5')] = v
+                elif k.startswith('bn4'):
+                    model_dict[k.replace('bn4', 'bn5')] = v
+                else:
+                    model_dict[k] = v
+        state_dict.update(model_dict)
+        self.load_state_dict(state_dict)
+
+class DeepLabv3_plus(nn.Module):
+    def __init__(self, nInputChannels=3, n_classes=21, os=16, pretrained=False, _print=True):
+        if _print:
+            print("Constructing DeepLabv3+ model...")
+            print("Number of classes: {}".format(n_classes))
+            print("Output stride: {}".format(os))
+            print("Number of Input Channels: {}".format(nInputChannels))
+        super(DeepLabv3_plus, self).__init__()
+
+        # Atrous Conv
+        self.xception_features = Xception(nInputChannels, os, pretrained)
+
+        # ASPP
+        if os == 16:
+            rates = [1, 6, 12, 18]
+        elif os == 8:
+            rates = [1, 12, 24, 36]
+            raise NotImplementedError
+        else:
+            raise NotImplementedError
+
+        self.aspp1 = ASPP_module_rate0(2048, 256, rate=rates[0])
+        self.aspp2 = ASPP_module(2048, 256, rate=rates[1])
+        self.aspp3 = ASPP_module(2048, 256, rate=rates[2])
+        self.aspp4 = ASPP_module(2048, 256, rate=rates[3])
+
+        self.relu = nn.ReLU()
+
+        self.global_avg_pool = nn.Sequential(nn.AdaptiveAvgPool2d((1, 1)),
+                                             nn.Conv2d(2048, 256, 1, stride=1, bias=False),
+                                             nn.BatchNorm2d(256),
+                                             nn.ReLU()
+                                             )
+
+        self.concat_projection_conv1 = nn.Conv2d(1280, 256, 1, bias=False)
+        self.concat_projection_bn1 = nn.BatchNorm2d(256)
+
+        # adopt [1x1, 48] for channel reduction.
+        self.feature_projection_conv1 = nn.Conv2d(256, 48, 1, bias=False)
+        self.feature_projection_bn1 = nn.BatchNorm2d(48)
+
+        self.decoder = nn.Sequential(Decoder_module(304, 256),
+                                     Decoder_module(256, 256)
+                                     )
+        self.semantic = nn.Conv2d(256, n_classes, kernel_size=1, stride=1)
+
+    def forward(self, input):
+        x, low_level_features = self.xception_features(input)
+        # print(x.size())
+        x1 = self.aspp1(x)
+        x2 = self.aspp2(x)
+        x3 = self.aspp3(x)
+        x4 = self.aspp4(x)
+        x5 = self.global_avg_pool(x)
+        x5 = F.upsample(x5, size=x4.size()[2:], mode='bilinear', align_corners=True)
+
+        x = torch.cat((x1, x2, x3, x4, x5), dim=1)
+
+        x = self.concat_projection_conv1(x)
+        x = self.concat_projection_bn1(x)
+        x = self.relu(x)
+        # print(x.size())
+
+        low_level_features = self.feature_projection_conv1(low_level_features)
+        low_level_features = self.feature_projection_bn1(low_level_features)
+        low_level_features = self.relu(low_level_features)
+
+        x = F.upsample(x, size=low_level_features.size()[2:], mode='bilinear', align_corners=True)
+        # print(low_level_features.size())
+        # print(x.size())
+        x = torch.cat((x, low_level_features), dim=1)
+        x = self.decoder(x)
+        x = self.semantic(x)
+        x = F.upsample(x, size=input.size()[2:], mode='bilinear', align_corners=True)
+
+        return x
+
+    def freeze_bn(self):
+        for m in self.xception_features.modules():
+            if isinstance(m, nn.BatchNorm2d):
+                m.eval()
+
+    def freeze_totally_bn(self):
+        for m in self.modules():
+            if isinstance(m, nn.BatchNorm2d):
+                m.eval()
+
+    def freeze_aspp_bn(self):
+        for m in self.aspp1.modules():
+            if isinstance(m, nn.BatchNorm2d):
+                m.eval()
+        for m in self.aspp2.modules():
+            if isinstance(m, nn.BatchNorm2d):
+                m.eval()
+        for m in self.aspp3.modules():
+            if isinstance(m, nn.BatchNorm2d):
+                m.eval()
+        for m in self.aspp4.modules():
+            if isinstance(m, nn.BatchNorm2d):
+                m.eval()
+
+    def learnable_parameters(self):
+        layer_features_BN = []
+        layer_features = []
+        layer_aspp = []
+        layer_projection  =[]
+        layer_decoder = []
+        layer_other = []
+        model_para = list(self.named_parameters())
+        for name,para in model_para:
+            if 'xception' in name:
+                if 'bn' in name or 'downsample.1.weight' in name or 'downsample.1.bias' in name:
+                    layer_features_BN.append(para)
+                else:
+                    layer_features.append(para)
+                    # print (name)
+            elif 'aspp' in name:
+                layer_aspp.append(para)
+            elif 'projection' in name:
+                layer_projection.append(para)
+            elif 'decode' in name:
+                layer_decoder.append(para)
+            elif 'global' not in name:
+                layer_other.append(para)
+        return layer_features_BN,layer_features,layer_aspp,layer_projection,layer_decoder,layer_other
+
+    def get_backbone_para(self):
+        layer_features = []
+        other_features = []
+        model_para = list(self.named_parameters())
+        for name, para in model_para:
+            if 'xception' in name:
+                layer_features.append(para)
+            else:
+                other_features.append(para)
+
+        return layer_features, other_features
+
+    def train_fixbn(self, mode=True, freeze_bn=True, freeze_bn_affine=False):
+        r"""Sets the module in training mode.
+
+        This has any effect only on certain modules. See documentations of
+        particular modules for details of their behaviors in training/evaluation
+        mode, if they are affected, e.g. :class:`Dropout`, :class:`BatchNorm`,
+        etc.
+
+        Returns:
+            Module: self
+        """
+        super(DeepLabv3_plus, self).train(mode)
+        if freeze_bn:
+            print("Freezing Mean/Var of BatchNorm2D.")
+            if freeze_bn_affine:
+                print("Freezing Weight/Bias of BatchNorm2D.")
+        if freeze_bn:
+            for m in self.xception_features.modules():
+                if isinstance(m, nn.BatchNorm2d):
+                    m.eval()
+                    if freeze_bn_affine:
+                        m.weight.requires_grad = False
+                        m.bias.requires_grad = False
+            # for m in self.aspp1.modules():
+            #     if isinstance(m, nn.BatchNorm2d):
+            #         m.eval()
+            #         if freeze_bn_affine:
+            #             m.weight.requires_grad = False
+            #             m.bias.requires_grad = False
+            # for m in self.aspp2.modules():
+            #     if isinstance(m, nn.BatchNorm2d):
+            #         m.eval()
+            #         if freeze_bn_affine:
+            #             m.weight.requires_grad = False
+            #             m.bias.requires_grad = False
+            # for m in self.aspp3.modules():
+            #     if isinstance(m, nn.BatchNorm2d):
+            #         m.eval()
+            #         if freeze_bn_affine:
+            #             m.weight.requires_grad = False
+            #             m.bias.requires_grad = False
+            # for m in self.aspp4.modules():
+            #     if isinstance(m, nn.BatchNorm2d):
+            #         m.eval()
+            #         if freeze_bn_affine:
+            #             m.weight.requires_grad = False
+            #             m.bias.requires_grad = False
+            # for m in self.global_avg_pool.modules():
+            #     if isinstance(m, nn.BatchNorm2d):
+            #         m.eval()
+            #         if freeze_bn_affine:
+            #             m.weight.requires_grad = False
+            #             m.bias.requires_grad = False
+            # for m in self.concat_projection_bn1.modules():
+            #     if isinstance(m, nn.BatchNorm2d):
+            #         m.eval()
+            #         if freeze_bn_affine:
+            #             m.weight.requires_grad = False
+            #             m.bias.requires_grad = False
+            # for m in self.feature_projection_bn1.modules():
+            #     if isinstance(m, nn.BatchNorm2d):
+            #         m.eval()
+            #         if freeze_bn_affine:
+            #             m.weight.requires_grad = False
+            #             m.bias.requires_grad = False
+
+    def __init_weight(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
+                m.weight.data.normal_(0, math.sqrt(2. / n))
+                # torch.nn.init.kaiming_normal_(m.weight)
+            elif isinstance(m, nn.BatchNorm2d):
+                m.weight.data.fill_(1)
+                m.bias.data.zero_()
+
+    def load_state_dict_new(self, state_dict):
+        own_state = self.state_dict()
+        #for name inshop_cos own_state:
+        #    print name
+        new_state_dict = OrderedDict()
+        for name, param in state_dict.items():
+            name = name.replace('module.','')
+            new_state_dict[name] = 0
+            if name not in own_state:
+                if 'num_batch' in name:
+                    continue
+                print ('unexpected key "{}" in state_dict'
+                       .format(name))
+                continue
+                # if isinstance(param, own_state):
+            if isinstance(param, Parameter):
+                    # backwards compatibility for serialized parameters
+                param = param.data
+            try:
+                own_state[name].copy_(param)
+            except:
+                print('While copying the parameter named {}, whose dimensions in the model are'
+                          ' {} and whose dimensions in the checkpoint are {}, ...'.format(
+                        name, own_state[name].size(), param.size()))
+                continue # i add inshop_cos 2018/02/01
+                # raise
+                    # print 'copying %s' %name
+                # if isinstance(param, own_state):
+                # backwards compatibility for serialized parameters
+            own_state[name].copy_(param)
+            # print 'copying %s' %name
+
+        missing = set(own_state.keys()) - set(new_state_dict.keys())
+        if len(missing) > 0:
+            print('missing keys in state_dict: "{}"'.format(missing))
+
+
+def get_1x_lr_params(model):
+    """
+    This generator returns all the parameters of the net except for
+    the last classification layer. Note that for each batchnorm layer,
+    requires_grad is set to False in deeplab_resnet.py, therefore this function does not return
+    any batchnorm parameter
+    """
+    b = [model.xception_features]
+    for i in range(len(b)):
+        for k in b[i].parameters():
+            if k.requires_grad:
+                yield k
+
+
+def get_10x_lr_params(model):
+    """
+    This generator returns all the parameters for the last layer of the net,
+    which does the classification of pixel into classes
+    """
+    b = [model.aspp1, model.aspp2, model.aspp3, model.aspp4, model.conv1, model.conv2, model.last_conv]
+    for j in range(len(b)):
+        for k in b[j].parameters():
+            if k.requires_grad:
+                yield k
+
+
+if __name__ == "__main__":
+    model = DeepLabv3_plus(nInputChannels=3, n_classes=21, os=16, pretrained=False, _print=True)
+    model.eval()
+    image = torch.randn(1, 3, 512, 512)*255
+    with torch.no_grad():
+        output = model.forward(image)
+    print(output.size())
+    # print(output)
+
+
+
+
+
+

TryYours-Virtual-Try-On/Graphonomy-master/networks/deeplab_xception_synBN.py

@@ -0,0 +1,596 @@
+import math
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.utils.model_zoo as model_zoo
+from torch.nn.parameter import Parameter
+from collections import OrderedDict
+from sync_batchnorm import SynchronizedBatchNorm1d, DataParallelWithCallback, SynchronizedBatchNorm2d
+
+
+def fixed_padding(inputs, kernel_size, rate):
+    kernel_size_effective = kernel_size + (kernel_size - 1) * (rate - 1)
+    pad_total = kernel_size_effective - 1
+    pad_beg = pad_total // 2
+    pad_end = pad_total - pad_beg
+    padded_inputs = F.pad(inputs, (pad_beg, pad_end, pad_beg, pad_end))
+    return padded_inputs
+
+class SeparableConv2d_aspp(nn.Module):
+    def __init__(self, inplanes, planes, kernel_size=3, stride=1, dilation=1, bias=False, padding=0):
+        super(SeparableConv2d_aspp, self).__init__()
+
+        self.depthwise = nn.Conv2d(inplanes, inplanes, kernel_size, stride, padding, dilation,
+                                   groups=inplanes, bias=bias)
+        self.depthwise_bn = SynchronizedBatchNorm2d(inplanes)
+        self.pointwise = nn.Conv2d(inplanes, planes, 1, 1, 0, 1, 1, bias=bias)
+        self.pointwise_bn = SynchronizedBatchNorm2d(planes)
+        self.relu = nn.ReLU()
+
+    def forward(self, x):
+        #         x = fixed_padding(x, self.depthwise.kernel_size[0], rate=self.depthwise.dilation[0])
+        x = self.depthwise(x)
+        x = self.depthwise_bn(x)
+        x = self.relu(x)
+        x = self.pointwise(x)
+        x = self.pointwise_bn(x)
+        x = self.relu(x)
+        return x
+
+class Decoder_module(nn.Module):
+    def __init__(self, inplanes, planes, rate=1):
+        super(Decoder_module, self).__init__()
+        self.atrous_convolution = SeparableConv2d_aspp(inplanes, planes, 3, stride=1, dilation=rate,padding=1)
+
+    def forward(self, x):
+        x = self.atrous_convolution(x)
+        return x
+
+class ASPP_module(nn.Module):
+    def __init__(self, inplanes, planes, rate):
+        super(ASPP_module, self).__init__()
+        if rate == 1:
+            raise RuntimeError()
+        else:
+            kernel_size = 3
+            padding = rate
+            self.atrous_convolution = SeparableConv2d_aspp(inplanes, planes, 3, stride=1, dilation=rate,
+                                                           padding=padding)
+
+    def forward(self, x):
+        x = self.atrous_convolution(x)
+        return x
+
+
+class ASPP_module_rate0(nn.Module):
+    def __init__(self, inplanes, planes, rate=1):
+        super(ASPP_module_rate0, self).__init__()
+        if rate == 1:
+            kernel_size = 1
+            padding = 0
+            self.atrous_convolution = nn.Conv2d(inplanes, planes, kernel_size=kernel_size,
+                                                stride=1, padding=padding, dilation=rate, bias=False)
+            self.bn = SynchronizedBatchNorm2d(planes, eps=1e-5, affine=True)
+            self.relu = nn.ReLU()
+        else:
+            raise RuntimeError()
+
+    def forward(self, x):
+        x = self.atrous_convolution(x)
+        x = self.bn(x)
+        return self.relu(x)
+
+
+class SeparableConv2d_same(nn.Module):
+    def __init__(self, inplanes, planes, kernel_size=3, stride=1, dilation=1, bias=False, padding=0):
+        super(SeparableConv2d_same, self).__init__()
+
+        self.depthwise = nn.Conv2d(inplanes, inplanes, kernel_size, stride, padding, dilation,
+                                   groups=inplanes, bias=bias)
+        self.depthwise_bn = SynchronizedBatchNorm2d(inplanes)
+        self.pointwise = nn.Conv2d(inplanes, planes, 1, 1, 0, 1, 1, bias=bias)
+        self.pointwise_bn = SynchronizedBatchNorm2d(planes)
+
+    def forward(self, x):
+        x = fixed_padding(x, self.depthwise.kernel_size[0], rate=self.depthwise.dilation[0])
+        x = self.depthwise(x)
+        x = self.depthwise_bn(x)
+        x = self.pointwise(x)
+        x = self.pointwise_bn(x)
+        return x
+
+
+class Block(nn.Module):
+    def __init__(self, inplanes, planes, reps, stride=1, dilation=1, start_with_relu=True, grow_first=True, is_last=False):
+        super(Block, self).__init__()
+
+        if planes != inplanes or stride != 1:
+            self.skip = nn.Conv2d(inplanes, planes, 1, stride=2, bias=False)
+            if is_last:
+                self.skip = nn.Conv2d(inplanes, planes, 1, stride=1, bias=False)
+            self.skipbn = SynchronizedBatchNorm2d(planes)
+        else:
+            self.skip = None
+
+        self.relu = nn.ReLU(inplace=True)
+        rep = []
+
+        filters = inplanes
+        if grow_first:
+            rep.append(self.relu)
+            rep.append(SeparableConv2d_same(inplanes, planes, 3, stride=1, dilation=dilation))
+#             rep.append(nn.BatchNorm2d(planes))
+            filters = planes
+
+        for i in range(reps - 1):
+            rep.append(self.relu)
+            rep.append(SeparableConv2d_same(filters, filters, 3, stride=1, dilation=dilation))
+#             rep.append(nn.BatchNorm2d(filters))
+
+        if not grow_first:
+            rep.append(self.relu)
+            rep.append(SeparableConv2d_same(inplanes, planes, 3, stride=1, dilation=dilation))
+#             rep.append(nn.BatchNorm2d(planes))
+
+        if not start_with_relu:
+            rep = rep[1:]
+
+        if stride != 1:
+            rep.append(self.relu)
+            rep.append(SeparableConv2d_same(planes, planes, 3, stride=2,dilation=dilation))
+
+        if is_last:
+            rep.append(self.relu)
+            rep.append(SeparableConv2d_same(planes, planes, 3, stride=1,dilation=dilation))
+
+
+        self.rep = nn.Sequential(*rep)
+
+    def forward(self, inp):
+        x = self.rep(inp)
+
+        if self.skip is not None:
+            skip = self.skip(inp)
+            skip = self.skipbn(skip)
+        else:
+            skip = inp
+        # print(x.size(),skip.size())
+        x += skip
+
+        return x
+
+class Block2(nn.Module):
+    def __init__(self, inplanes, planes, reps, stride=1, dilation=1, start_with_relu=True, grow_first=True, is_last=False):
+        super(Block2, self).__init__()
+
+        if planes != inplanes or stride != 1:
+            self.skip = nn.Conv2d(inplanes, planes, 1, stride=stride, bias=False)
+            self.skipbn = SynchronizedBatchNorm2d(planes)
+        else:
+            self.skip = None
+
+        self.relu = nn.ReLU(inplace=True)
+        rep = []
+
+        filters = inplanes
+        if grow_first:
+            rep.append(self.relu)
+            rep.append(SeparableConv2d_same(inplanes, planes, 3, stride=1, dilation=dilation))
+#             rep.append(nn.BatchNorm2d(planes))
+            filters = planes
+
+        for i in range(reps - 1):
+            rep.append(self.relu)
+            rep.append(SeparableConv2d_same(filters, filters, 3, stride=1, dilation=dilation))
+#             rep.append(nn.BatchNorm2d(filters))
+
+        if not grow_first:
+            rep.append(self.relu)
+            rep.append(SeparableConv2d_same(inplanes, planes, 3, stride=1, dilation=dilation))
+#             rep.append(nn.BatchNorm2d(planes))
+
+        if not start_with_relu:
+            rep = rep[1:]
+
+        if stride != 1:
+            self.block2_lastconv = nn.Sequential(*[self.relu,SeparableConv2d_same(planes, planes, 3, stride=2,dilation=dilation)])
+
+        if is_last:
+            rep.append(SeparableConv2d_same(planes, planes, 3, stride=1))
+
+
+        self.rep = nn.Sequential(*rep)
+
+    def forward(self, inp):
+        x = self.rep(inp)
+        low_middle = x.clone()
+        x1 = x
+        x1 = self.block2_lastconv(x1)
+        if self.skip is not None:
+            skip = self.skip(inp)
+            skip = self.skipbn(skip)
+        else:
+            skip = inp
+
+        x1 += skip
+
+        return x1,low_middle
+
+class Xception(nn.Module):
+    """
+    Modified Alighed Xception
+    """
+    def __init__(self, inplanes=3, os=16, pretrained=False):
+        super(Xception, self).__init__()
+
+        if os == 16:
+            entry_block3_stride = 2
+            middle_block_rate = 1
+            exit_block_rates = (1, 2)
+        elif os == 8:
+            entry_block3_stride = 1
+            middle_block_rate = 2
+            exit_block_rates = (2, 4)
+        else:
+            raise NotImplementedError
+
+
+        # Entry flow
+        self.conv1 = nn.Conv2d(inplanes, 32, 3, stride=2, padding=1, bias=False)
+        self.bn1 = SynchronizedBatchNorm2d(32)
+        self.relu = nn.ReLU(inplace=True)
+
+        self.conv2 = nn.Conv2d(32, 64, 3, stride=1, padding=1, bias=False)
+        self.bn2 = SynchronizedBatchNorm2d(64)
+
+        self.block1 = Block(64, 128, reps=2, stride=2, start_with_relu=False)
+        self.block2 = Block2(128, 256, reps=2, stride=2, start_with_relu=True, grow_first=True)
+        self.block3 = Block(256, 728, reps=2, stride=entry_block3_stride, start_with_relu=True, grow_first=True)
+
+        # Middle flow
+        self.block4  = Block(728, 728, reps=3, stride=1, dilation=middle_block_rate, start_with_relu=True, grow_first=True)
+        self.block5  = Block(728, 728, reps=3, stride=1, dilation=middle_block_rate, start_with_relu=True, grow_first=True)
+        self.block6  = Block(728, 728, reps=3, stride=1, dilation=middle_block_rate, start_with_relu=True, grow_first=True)
+        self.block7  = Block(728, 728, reps=3, stride=1, dilation=middle_block_rate, start_with_relu=True, grow_first=True)
+        self.block8  = Block(728, 728, reps=3, stride=1, dilation=middle_block_rate, start_with_relu=True, grow_first=True)
+        self.block9  = Block(728, 728, reps=3, stride=1, dilation=middle_block_rate, start_with_relu=True, grow_first=True)
+        self.block10 = Block(728, 728, reps=3, stride=1, dilation=middle_block_rate, start_with_relu=True, grow_first=True)
+        self.block11 = Block(728, 728, reps=3, stride=1, dilation=middle_block_rate, start_with_relu=True, grow_first=True)
+        self.block12 = Block(728, 728, reps=3, stride=1, dilation=middle_block_rate, start_with_relu=True, grow_first=True)
+        self.block13 = Block(728, 728, reps=3, stride=1, dilation=middle_block_rate, start_with_relu=True, grow_first=True)
+        self.block14 = Block(728, 728, reps=3, stride=1, dilation=middle_block_rate, start_with_relu=True, grow_first=True)
+        self.block15 = Block(728, 728, reps=3, stride=1, dilation=middle_block_rate, start_with_relu=True, grow_first=True)
+        self.block16 = Block(728, 728, reps=3, stride=1, dilation=middle_block_rate, start_with_relu=True, grow_first=True)
+        self.block17 = Block(728, 728, reps=3, stride=1, dilation=middle_block_rate, start_with_relu=True, grow_first=True)
+        self.block18 = Block(728, 728, reps=3, stride=1, dilation=middle_block_rate, start_with_relu=True, grow_first=True)
+        self.block19 = Block(728, 728, reps=3, stride=1, dilation=middle_block_rate, start_with_relu=True, grow_first=True)
+
+        # Exit flow
+        self.block20 = Block(728, 1024, reps=2, stride=1, dilation=exit_block_rates[0],
+                             start_with_relu=True, grow_first=False, is_last=True)
+
+        self.conv3 = SeparableConv2d_aspp(1024, 1536, 3, stride=1, dilation=exit_block_rates[1],padding=exit_block_rates[1])
+        # self.bn3 = nn.BatchNorm2d(1536)
+
+        self.conv4 = SeparableConv2d_aspp(1536, 1536, 3, stride=1, dilation=exit_block_rates[1],padding=exit_block_rates[1])
+        # self.bn4 = nn.BatchNorm2d(1536)
+
+        self.conv5 = SeparableConv2d_aspp(1536, 2048, 3, stride=1, dilation=exit_block_rates[1],padding=exit_block_rates[1])
+        # self.bn5 = nn.BatchNorm2d(2048)
+
+        # Init weights
+        # self.__init_weight()
+
+        # Load pretrained model
+        if pretrained:
+            self.__load_xception_pretrained()
+
+    def forward(self, x):
+        # Entry flow
+        x = self.conv1(x)
+        x = self.bn1(x)
+        x = self.relu(x)
+        # print('conv1 ',x.size())
+        x = self.conv2(x)
+        x = self.bn2(x)
+        x = self.relu(x)
+
+        x = self.block1(x)
+        # print('block1',x.size())
+        # low_level_feat = x
+        x,low_level_feat = self.block2(x)
+        # print('block2',x.size())
+        x = self.block3(x)
+        # print('xception block3 ',x.size())
+
+        # Middle flow
+        x = self.block4(x)
+        x = self.block5(x)
+        x = self.block6(x)
+        x = self.block7(x)
+        x = self.block8(x)
+        x = self.block9(x)
+        x = self.block10(x)
+        x = self.block11(x)
+        x = self.block12(x)
+        x = self.block13(x)
+        x = self.block14(x)
+        x = self.block15(x)
+        x = self.block16(x)
+        x = self.block17(x)
+        x = self.block18(x)
+        x = self.block19(x)
+
+        # Exit flow
+        x = self.block20(x)
+        x = self.conv3(x)
+        # x = self.bn3(x)
+        x = self.relu(x)
+
+        x = self.conv4(x)
+        # x = self.bn4(x)
+        x = self.relu(x)
+
+        x = self.conv5(x)
+        # x = self.bn5(x)
+        x = self.relu(x)
+
+        return x, low_level_feat
+
+    def __init_weight(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                # n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
+                # m.weight.data.normal_(0, math.sqrt(2. / n))
+                torch.nn.init.kaiming_normal_(m.weight)
+            elif isinstance(m, nn.BatchNorm2d):
+                m.weight.data.fill_(1)
+                m.bias.data.zero_()
+
+    def __load_xception_pretrained(self):
+        pretrain_dict = model_zoo.load_url('http://data.lip6.fr/cadene/pretrainedmodels/xception-b5690688.pth')
+        model_dict = {}
+        state_dict = self.state_dict()
+
+        for k, v in pretrain_dict.items():
+            if k in state_dict:
+                if 'pointwise' in k:
+                    v = v.unsqueeze(-1).unsqueeze(-1)
+                if k.startswith('block12'):
+                    model_dict[k.replace('block12', 'block20')] = v
+                elif k.startswith('block11'):
+                    model_dict[k.replace('block11', 'block12')] = v
+                    model_dict[k.replace('block11', 'block13')] = v
+                    model_dict[k.replace('block11', 'block14')] = v
+                    model_dict[k.replace('block11', 'block15')] = v
+                    model_dict[k.replace('block11', 'block16')] = v
+                    model_dict[k.replace('block11', 'block17')] = v
+                    model_dict[k.replace('block11', 'block18')] = v
+                    model_dict[k.replace('block11', 'block19')] = v
+                elif k.startswith('conv3'):
+                    model_dict[k] = v
+                elif k.startswith('bn3'):
+                    model_dict[k] = v
+                    model_dict[k.replace('bn3', 'bn4')] = v
+                elif k.startswith('conv4'):
+                    model_dict[k.replace('conv4', 'conv5')] = v
+                elif k.startswith('bn4'):
+                    model_dict[k.replace('bn4', 'bn5')] = v
+                else:
+                    model_dict[k] = v
+        state_dict.update(model_dict)
+        self.load_state_dict(state_dict)
+
+class DeepLabv3_plus(nn.Module):
+    def __init__(self, nInputChannels=3, n_classes=21, os=16, pretrained=False, _print=True):
+        if _print:
+            print("Constructing DeepLabv3+ model...")
+            print("Number of classes: {}".format(n_classes))
+            print("Output stride: {}".format(os))
+            print("Number of Input Channels: {}".format(nInputChannels))
+        super(DeepLabv3_plus, self).__init__()
+
+        # Atrous Conv
+        self.xception_features = Xception(nInputChannels, os, pretrained)
+
+        # ASPP
+        if os == 16:
+            rates = [1, 6, 12, 18]
+        elif os == 8:
+            rates = [1, 12, 24, 36]
+        else:
+            raise NotImplementedError
+
+        self.aspp1 = ASPP_module_rate0(2048, 256, rate=rates[0])
+        self.aspp2 = ASPP_module(2048, 256, rate=rates[1])
+        self.aspp3 = ASPP_module(2048, 256, rate=rates[2])
+        self.aspp4 = ASPP_module(2048, 256, rate=rates[3])
+
+        self.relu = nn.ReLU()
+
+        self.global_avg_pool = nn.Sequential(nn.AdaptiveAvgPool2d((1, 1)),
+                                             nn.Conv2d(2048, 256, 1, stride=1, bias=False),
+                                             SynchronizedBatchNorm2d(256),
+                                             nn.ReLU()
+                                             )
+
+        self.concat_projection_conv1 = nn.Conv2d(1280, 256, 1, bias=False)
+        self.concat_projection_bn1 = SynchronizedBatchNorm2d(256)
+
+        # adopt [1x1, 48] for channel reduction.
+        self.feature_projection_conv1 = nn.Conv2d(256, 48, 1, bias=False)
+        self.feature_projection_bn1 = SynchronizedBatchNorm2d(48)
+
+        self.decoder = nn.Sequential(Decoder_module(304, 256),
+                                     Decoder_module(256, 256)
+                                     )
+        self.semantic = nn.Conv2d(256, n_classes, kernel_size=1, stride=1)
+
+    def forward(self, input):
+        x, low_level_features = self.xception_features(input)
+        # print(x.size())
+        x1 = self.aspp1(x)
+        x2 = self.aspp2(x)
+        x3 = self.aspp3(x)
+        x4 = self.aspp4(x)
+        x5 = self.global_avg_pool(x)
+        x5 = F.upsample(x5, size=x4.size()[2:], mode='bilinear', align_corners=True)
+
+        x = torch.cat((x1, x2, x3, x4, x5), dim=1)
+
+        x = self.concat_projection_conv1(x)
+        x = self.concat_projection_bn1(x)
+        x = self.relu(x)
+        # print(x.size())
+        x = F.upsample(x, size=low_level_features.size()[2:], mode='bilinear', align_corners=True)
+
+        low_level_features = self.feature_projection_conv1(low_level_features)
+        low_level_features = self.feature_projection_bn1(low_level_features)
+        low_level_features = self.relu(low_level_features)
+        # print(low_level_features.size())
+        # print(x.size())
+        x = torch.cat((x, low_level_features), dim=1)
+        x = self.decoder(x)
+        x = self.semantic(x)
+        x = F.upsample(x, size=input.size()[2:], mode='bilinear', align_corners=True)
+
+        return x
+
+    def freeze_bn(self):
+        for m in self.xception_features.modules():
+            if isinstance(m, nn.BatchNorm2d) or isinstance(m,SynchronizedBatchNorm2d):
+                m.eval()
+
+    def freeze_aspp_bn(self):
+        for m in self.aspp1.modules():
+            if isinstance(m, nn.BatchNorm2d):
+                m.eval()
+        for m in self.aspp2.modules():
+            if isinstance(m, nn.BatchNorm2d):
+                m.eval()
+        for m in self.aspp3.modules():
+            if isinstance(m, nn.BatchNorm2d):
+                m.eval()
+        for m in self.aspp4.modules():
+            if isinstance(m, nn.BatchNorm2d):
+                m.eval()
+
+    def learnable_parameters(self):
+        layer_features_BN = []
+        layer_features = []
+        layer_aspp = []
+        layer_projection  =[]
+        layer_decoder = []
+        layer_other = []
+        model_para = list(self.named_parameters())
+        for name,para in model_para:
+            if 'xception' in name:
+                if 'bn' in name or 'downsample.1.weight' in name or 'downsample.1.bias' in name:
+                    layer_features_BN.append(para)
+                else:
+                    layer_features.append(para)
+                    # print (name)
+            elif 'aspp' in name:
+                layer_aspp.append(para)
+            elif 'projection' in name:
+                layer_projection.append(para)
+            elif 'decode' in name:
+                layer_decoder.append(para)
+            else:
+                layer_other.append(para)
+        return layer_features_BN,layer_features,layer_aspp,layer_projection,layer_decoder,layer_other
+
+
+    def __init_weight(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
+                m.weight.data.normal_(0, math.sqrt(2. / n))
+                # torch.nn.init.kaiming_normal_(m.weight)
+            elif isinstance(m, nn.BatchNorm2d):
+                m.weight.data.fill_(1)
+                m.bias.data.zero_()
+
+    def load_state_dict_new(self, state_dict):
+        own_state = self.state_dict()
+        #for name inshop_cos own_state:
+        #    print name
+        new_state_dict = OrderedDict()
+        for name, param in state_dict.items():
+            name = name.replace('module.','')
+            new_state_dict[name] = 0
+            if name not in own_state:
+                if 'num_batch' in name:
+                    continue
+                print ('unexpected key "{}" in state_dict'
+                       .format(name))
+                continue
+                # if isinstance(param, own_state):
+            if isinstance(param, Parameter):
+                    # backwards compatibility for serialized parameters
+                param = param.data
+            try:
+                own_state[name].copy_(param)
+            except:
+                print('While copying the parameter named {}, whose dimensions in the model are'
+                          ' {} and whose dimensions in the checkpoint are {}, ...'.format(
+                        name, own_state[name].size(), param.size()))
+                continue # i add inshop_cos 2018/02/01
+                # raise
+                    # print 'copying %s' %name
+                # if isinstance(param, own_state):
+                # backwards compatibility for serialized parameters
+            own_state[name].copy_(param)
+            # print 'copying %s' %name
+
+        missing = set(own_state.keys()) - set(new_state_dict.keys())
+        if len(missing) > 0:
+            print('missing keys in state_dict: "{}"'.format(missing))
+
+
+
+
+def get_1x_lr_params(model):
+    """
+    This generator returns all the parameters of the net except for
+    the last classification layer. Note that for each batchnorm layer,
+    requires_grad is set to False in deeplab_resnet.py, therefore this function does not return
+    any batchnorm parameter
+    """
+    b = [model.xception_features]
+    for i in range(len(b)):
+        for k in b[i].parameters():
+            if k.requires_grad:
+                yield k
+
+
+def get_10x_lr_params(model):
+    """
+    This generator returns all the parameters for the last layer of the net,
+    which does the classification of pixel into classes
+    """
+    b = [model.aspp1, model.aspp2, model.aspp3, model.aspp4, model.conv1, model.conv2, model.last_conv]
+    for j in range(len(b)):
+        for k in b[j].parameters():
+            if k.requires_grad:
+                yield k
+
+
+if __name__ == "__main__":
+    model = DeepLabv3_plus(nInputChannels=3, n_classes=21, os=16, pretrained=False, _print=True)
+    model.eval()
+    # ckt = torch.load('C:\\Users\gaoyi\code_python\deeplab_v3plus.pth')
+    # model.load_state_dict_new(ckt)
+
+
+    image = torch.randn(1, 3, 512, 512)*255
+    with torch.no_grad():
+        output = model.forward(image)
+    print(output.size())
+    # print(output)
+
+
+
+
+
+

TryYours-Virtual-Try-On/Graphonomy-master/networks/deeplab_xception_transfer.py

@@ -0,0 +1,1003 @@
+import math
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.utils.model_zoo as model_zoo
+from torch.nn.parameter import Parameter
+import numpy as np
+from collections import OrderedDict
+from torch.nn import Parameter
+from networks import deeplab_xception,gcn, deeplab_xception_synBN
+import pdb
+
+#######################
+# base model
+#######################
+
+class deeplab_xception_transfer_basemodel(deeplab_xception.DeepLabv3_plus):
+    def __init__(self,nInputChannels=3, n_classes=7, os=16,input_channels=256,hidden_layers=128,out_channels=256):
+        super(deeplab_xception_transfer_basemodel, self).__init__(nInputChannels=nInputChannels, n_classes=n_classes,
+                                                                  os=os,)
+        ### source graph
+        # self.source_featuremap_2_graph = gcn.Featuremaps_to_Graph(input_channels=input_channels, hidden_layers=hidden_layers,
+        #                                                    nodes=n_classes)
+        # self.source_graph_conv1 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        # self.source_graph_conv2 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        # self.source_graph_conv3 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        #
+        # self.source_graph_2_fea = gcn.Graph_to_Featuremaps(input_channels=input_channels, output_channels=out_channels,
+        #                                             hidden_layers=hidden_layers, nodes=n_classes
+        #                                             )
+        # self.source_skip_conv = nn.Sequential(*[nn.Conv2d(input_channels, input_channels, kernel_size=1),
+        #                                  nn.ReLU(True)])
+
+        ### target graph
+        self.target_featuremap_2_graph = gcn.Featuremaps_to_Graph(input_channels=input_channels, hidden_layers=hidden_layers,
+                                                           nodes=n_classes)
+        self.target_graph_conv1 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.target_graph_conv2 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.target_graph_conv3 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+
+        self.target_graph_2_fea = gcn.Graph_to_Featuremaps(input_channels=input_channels, output_channels=out_channels,
+                                                    hidden_layers=hidden_layers, nodes=n_classes
+                                                    )
+        self.target_skip_conv = nn.Sequential(*[nn.Conv2d(input_channels, input_channels, kernel_size=1),
+                                         nn.ReLU(True)])
+
+    def load_source_model(self,state_dict):
+        own_state = self.state_dict()
+        # for name inshop_cos own_state:
+        #    print name
+        new_state_dict = OrderedDict()
+        for name, param in state_dict.items():
+            name = name.replace('module.', '')
+            if 'graph' in name and 'source' not in name and 'target' not in name and 'fc_graph' not in name and 'transpose_graph' not in name:
+                if 'featuremap_2_graph' in name:
+                    name = name.replace('featuremap_2_graph','source_featuremap_2_graph')
+                else:
+                    name = name.replace('graph','source_graph')
+            new_state_dict[name] = 0
+            if name not in own_state:
+                if 'num_batch' in name:
+                    continue
+                print('unexpected key "{}" in state_dict'
+                      .format(name))
+                continue
+                # if isinstance(param, own_state):
+            if isinstance(param, Parameter):
+                # backwards compatibility for serialized parameters
+                param = param.data
+            try:
+                own_state[name].copy_(param)
+            except:
+                print('While copying the parameter named {}, whose dimensions in the model are'
+                      ' {} and whose dimensions in the checkpoint are {}, ...'.format(
+                    name, own_state[name].size(), param.size()))
+                continue  # i add inshop_cos 2018/02/01
+            own_state[name].copy_(param)
+            # print 'copying %s' %name
+
+        missing = set(own_state.keys()) - set(new_state_dict.keys())
+        if len(missing) > 0:
+            print('missing keys in state_dict: "{}"'.format(missing))
+
+    def get_target_parameter(self):
+        l = []
+        other = []
+        for name, k in self.named_parameters():
+            if 'target' in name or 'semantic' in name:
+                l.append(k)
+            else:
+                other.append(k)
+        return l, other
+
+    def get_semantic_parameter(self):
+        l = []
+        for name, k in self.named_parameters():
+            if 'semantic' in name:
+                l.append(k)
+        return l
+
+    def get_source_parameter(self):
+        l = []
+        for name, k in self.named_parameters():
+            if 'source' in name:
+                l.append(k)
+        return l
+
+    def forward(self, input,adj1_target=None, adj2_source=None,adj3_transfer=None ):
+        x, low_level_features = self.xception_features(input)
+        # print(x.size())
+        x1 = self.aspp1(x)
+        x2 = self.aspp2(x)
+        x3 = self.aspp3(x)
+        x4 = self.aspp4(x)
+        x5 = self.global_avg_pool(x)
+        x5 = F.upsample(x5, size=x4.size()[2:], mode='bilinear', align_corners=True)
+
+        x = torch.cat((x1, x2, x3, x4, x5), dim=1)
+
+        x = self.concat_projection_conv1(x)
+        x = self.concat_projection_bn1(x)
+        x = self.relu(x)
+        # print(x.size())
+        x = F.upsample(x, size=low_level_features.size()[2:], mode='bilinear', align_corners=True)
+
+        low_level_features = self.feature_projection_conv1(low_level_features)
+        low_level_features = self.feature_projection_bn1(low_level_features)
+        low_level_features = self.relu(low_level_features)
+        # print(low_level_features.size())
+        # print(x.size())
+        x = torch.cat((x, low_level_features), dim=1)
+        x = self.decoder(x)
+
+        ### add graph
+
+
+        # target graph
+        # print('x size',x.size(),adj1.size())
+        graph = self.target_featuremap_2_graph(x)
+
+        # graph combine
+        # print(graph.size(),source_2_target_graph.size())
+        # graph = self.fc_graph.forward(graph,relu=True)
+        # print(graph.size())
+
+        graph = self.target_graph_conv1.forward(graph, adj=adj1_target, relu=True)
+        graph = self.target_graph_conv2.forward(graph, adj=adj1_target, relu=True)
+        graph = self.target_graph_conv3.forward(graph, adj=adj1_target, relu=True)
+        # print(graph.size(),x.size())
+        # graph = self.gcn_encode.forward(graph,relu=True)
+        # graph = self.graph_conv2.forward(graph,adj=adj2,relu=True)
+        # graph = self.gcn_decode.forward(graph,relu=True)
+        graph = self.target_graph_2_fea.forward(graph, x)
+        x = self.target_skip_conv(x)
+        x = x + graph
+
+        ###
+        x = self.semantic(x)
+        x = F.upsample(x, size=input.size()[2:], mode='bilinear', align_corners=True)
+
+        return x
+
+class deeplab_xception_transfer_basemodel_savememory(deeplab_xception.DeepLabv3_plus):
+    def __init__(self,nInputChannels=3, n_classes=7, os=16,input_channels=256,hidden_layers=128,out_channels=256):
+        super(deeplab_xception_transfer_basemodel_savememory, self).__init__(nInputChannels=nInputChannels, n_classes=n_classes,
+                                                                  os=os,)
+        ### source graph
+
+        ### target graph
+        self.target_featuremap_2_graph = gcn.Featuremaps_to_Graph(input_channels=input_channels, hidden_layers=hidden_layers,
+                                                           nodes=n_classes)
+        self.target_graph_conv1 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.target_graph_conv2 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.target_graph_conv3 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+
+        self.target_graph_2_fea = gcn.Graph_to_Featuremaps_savemem(input_channels=input_channels, output_channels=out_channels,
+                                                                   hidden_layers=hidden_layers, nodes=n_classes
+                                                                   )
+        self.target_skip_conv = nn.Sequential(*[nn.Conv2d(input_channels, input_channels, kernel_size=1),
+                                         nn.ReLU(True)])
+
+    def load_source_model(self,state_dict):
+        own_state = self.state_dict()
+        # for name inshop_cos own_state:
+        #    print name
+        new_state_dict = OrderedDict()
+        for name, param in state_dict.items():
+            name = name.replace('module.', '')
+            if 'graph' in name and 'source' not in name and 'target' not in name and 'fc_graph' not in name and 'transpose_graph' not in name:
+                if 'featuremap_2_graph' in name:
+                    name = name.replace('featuremap_2_graph','source_featuremap_2_graph')
+                else:
+                    name = name.replace('graph','source_graph')
+            new_state_dict[name] = 0
+            if name not in own_state:
+                if 'num_batch' in name:
+                    continue
+                print('unexpected key "{}" in state_dict'
+                      .format(name))
+                continue
+                # if isinstance(param, own_state):
+            if isinstance(param, Parameter):
+                # backwards compatibility for serialized parameters
+                param = param.data
+            try:
+                own_state[name].copy_(param)
+            except:
+                print('While copying the parameter named {}, whose dimensions in the model are'
+                      ' {} and whose dimensions in the checkpoint are {}, ...'.format(
+                    name, own_state[name].size(), param.size()))
+                continue  # i add inshop_cos 2018/02/01
+            own_state[name].copy_(param)
+            # print 'copying %s' %name
+
+        missing = set(own_state.keys()) - set(new_state_dict.keys())
+        if len(missing) > 0:
+            print('missing keys in state_dict: "{}"'.format(missing))
+
+    def get_target_parameter(self):
+        l = []
+        other = []
+        for name, k in self.named_parameters():
+            if 'target' in name or 'semantic' in name:
+                l.append(k)
+            else:
+                other.append(k)
+        return l, other
+
+    def get_semantic_parameter(self):
+        l = []
+        for name, k in self.named_parameters():
+            if 'semantic' in name:
+                l.append(k)
+        return l
+
+    def get_source_parameter(self):
+        l = []
+        for name, k in self.named_parameters():
+            if 'source' in name:
+                l.append(k)
+        return l
+
+    def forward(self, input,adj1_target=None, adj2_source=None,adj3_transfer=None ):
+        x, low_level_features = self.xception_features(input)
+        # print(x.size())
+        x1 = self.aspp1(x)
+        x2 = self.aspp2(x)
+        x3 = self.aspp3(x)
+        x4 = self.aspp4(x)
+        x5 = self.global_avg_pool(x)
+        x5 = F.upsample(x5, size=x4.size()[2:], mode='bilinear', align_corners=True)
+
+        x = torch.cat((x1, x2, x3, x4, x5), dim=1)
+
+        x = self.concat_projection_conv1(x)
+        x = self.concat_projection_bn1(x)
+        x = self.relu(x)
+        # print(x.size())
+        x = F.upsample(x, size=low_level_features.size()[2:], mode='bilinear', align_corners=True)
+
+        low_level_features = self.feature_projection_conv1(low_level_features)
+        low_level_features = self.feature_projection_bn1(low_level_features)
+        low_level_features = self.relu(low_level_features)
+        # print(low_level_features.size())
+        # print(x.size())
+        x = torch.cat((x, low_level_features), dim=1)
+        x = self.decoder(x)
+
+        ### add graph
+
+
+        # target graph
+        # print('x size',x.size(),adj1.size())
+        graph = self.target_featuremap_2_graph(x)
+
+        # graph combine
+        # print(graph.size(),source_2_target_graph.size())
+        # graph = self.fc_graph.forward(graph,relu=True)
+        # print(graph.size())
+
+        graph = self.target_graph_conv1.forward(graph, adj=adj1_target, relu=True)
+        graph = self.target_graph_conv2.forward(graph, adj=adj1_target, relu=True)
+        graph = self.target_graph_conv3.forward(graph, adj=adj1_target, relu=True)
+        # print(graph.size(),x.size())
+        # graph = self.gcn_encode.forward(graph,relu=True)
+        # graph = self.graph_conv2.forward(graph,adj=adj2,relu=True)
+        # graph = self.gcn_decode.forward(graph,relu=True)
+        graph = self.target_graph_2_fea.forward(graph, x)
+        x = self.target_skip_conv(x)
+        x = x + graph
+
+        ###
+        x = self.semantic(x)
+        x = F.upsample(x, size=input.size()[2:], mode='bilinear', align_corners=True)
+
+        return x
+
+class deeplab_xception_transfer_basemodel_synBN(deeplab_xception_synBN.DeepLabv3_plus):
+    def __init__(self,nInputChannels=3, n_classes=7, os=16,input_channels=256,hidden_layers=128,out_channels=256):
+        super(deeplab_xception_transfer_basemodel_synBN, self).__init__(nInputChannels=nInputChannels, n_classes=n_classes,
+                                                                  os=os,)
+        ### source graph
+        # self.source_featuremap_2_graph = gcn.Featuremaps_to_Graph(input_channels=input_channels, hidden_layers=hidden_layers,
+        #                                                    nodes=n_classes)
+        # self.source_graph_conv1 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        # self.source_graph_conv2 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        # self.source_graph_conv3 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        #
+        # self.source_graph_2_fea = gcn.Graph_to_Featuremaps(input_channels=input_channels, output_channels=out_channels,
+        #                                             hidden_layers=hidden_layers, nodes=n_classes
+        #                                             )
+        # self.source_skip_conv = nn.Sequential(*[nn.Conv2d(input_channels, input_channels, kernel_size=1),
+        #                                  nn.ReLU(True)])
+
+        ### target graph
+        self.target_featuremap_2_graph = gcn.Featuremaps_to_Graph(input_channels=input_channels, hidden_layers=hidden_layers,
+                                                           nodes=n_classes)
+        self.target_graph_conv1 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.target_graph_conv2 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.target_graph_conv3 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+
+        self.target_graph_2_fea = gcn.Graph_to_Featuremaps(input_channels=input_channels, output_channels=out_channels,
+                                                    hidden_layers=hidden_layers, nodes=n_classes
+                                                    )
+        self.target_skip_conv = nn.Sequential(*[nn.Conv2d(input_channels, input_channels, kernel_size=1),
+                                         nn.ReLU(True)])
+
+    def load_source_model(self,state_dict):
+        own_state = self.state_dict()
+        # for name inshop_cos own_state:
+        #    print name
+        new_state_dict = OrderedDict()
+        for name, param in state_dict.items():
+            name = name.replace('module.', '')
+
+            if 'graph' in name and 'source' not in name and 'target' not in name:
+                if 'featuremap_2_graph' in name:
+                    name = name.replace('featuremap_2_graph','source_featuremap_2_graph')
+                else:
+                    name = name.replace('graph','source_graph')
+            new_state_dict[name] = 0
+            if name not in own_state:
+                if 'num_batch' in name:
+                    continue
+                print('unexpected key "{}" in state_dict'
+                      .format(name))
+                continue
+                # if isinstance(param, own_state):
+            if isinstance(param, Parameter):
+                # backwards compatibility for serialized parameters
+                param = param.data
+            try:
+                own_state[name].copy_(param)
+            except:
+                print('While copying the parameter named {}, whose dimensions in the model are'
+                      ' {} and whose dimensions in the checkpoint are {}, ...'.format(
+                    name, own_state[name].size(), param.size()))
+                continue  # i add inshop_cos 2018/02/01
+            own_state[name].copy_(param)
+            # print 'copying %s' %name
+
+        missing = set(own_state.keys()) - set(new_state_dict.keys())
+        if len(missing) > 0:
+            print('missing keys in state_dict: "{}"'.format(missing))
+
+    def get_target_parameter(self):
+        l = []
+        other = []
+        for name, k in self.named_parameters():
+            if 'target' in name or 'semantic' in name:
+                l.append(k)
+            else:
+                other.append(k)
+        return l, other
+
+    def get_semantic_parameter(self):
+        l = []
+        for name, k in self.named_parameters():
+            if 'semantic' in name:
+                l.append(k)
+        return l
+
+    def get_source_parameter(self):
+        l = []
+        for name, k in self.named_parameters():
+            if 'source' in name:
+                l.append(k)
+        return l
+
+    def forward(self, input,adj1_target=None, adj2_source=None,adj3_transfer=None ):
+        x, low_level_features = self.xception_features(input)
+        # print(x.size())
+        x1 = self.aspp1(x)
+        x2 = self.aspp2(x)
+        x3 = self.aspp3(x)
+        x4 = self.aspp4(x)
+        x5 = self.global_avg_pool(x)
+        x5 = F.upsample(x5, size=x4.size()[2:], mode='bilinear', align_corners=True)
+
+        x = torch.cat((x1, x2, x3, x4, x5), dim=1)
+
+        x = self.concat_projection_conv1(x)
+        x = self.concat_projection_bn1(x)
+        x = self.relu(x)
+        # print(x.size())
+        x = F.upsample(x, size=low_level_features.size()[2:], mode='bilinear', align_corners=True)
+
+        low_level_features = self.feature_projection_conv1(low_level_features)
+        low_level_features = self.feature_projection_bn1(low_level_features)
+        low_level_features = self.relu(low_level_features)
+        # print(low_level_features.size())
+        # print(x.size())
+        x = torch.cat((x, low_level_features), dim=1)
+        x = self.decoder(x)
+
+        ### add graph
+
+
+        # target graph
+        # print('x size',x.size(),adj1.size())
+        graph = self.target_featuremap_2_graph(x)
+
+        # graph combine
+        # print(graph.size(),source_2_target_graph.size())
+        # graph = self.fc_graph.forward(graph,relu=True)
+        # print(graph.size())
+
+        graph = self.target_graph_conv1.forward(graph, adj=adj1_target, relu=True)
+        graph = self.target_graph_conv2.forward(graph, adj=adj1_target, relu=True)
+        graph = self.target_graph_conv3.forward(graph, adj=adj1_target, relu=True)
+        # print(graph.size(),x.size())
+        # graph = self.gcn_encode.forward(graph,relu=True)
+        # graph = self.graph_conv2.forward(graph,adj=adj2,relu=True)
+        # graph = self.gcn_decode.forward(graph,relu=True)
+        graph = self.target_graph_2_fea.forward(graph, x)
+        x = self.target_skip_conv(x)
+        x = x + graph
+
+        ###
+        x = self.semantic(x)
+        x = F.upsample(x, size=input.size()[2:], mode='bilinear', align_corners=True)
+
+        return x
+
+class deeplab_xception_transfer_basemodel_synBN_savememory(deeplab_xception_synBN.DeepLabv3_plus):
+    def __init__(self,nInputChannels=3, n_classes=7, os=16,input_channels=256,hidden_layers=128,out_channels=256):
+        super(deeplab_xception_transfer_basemodel_synBN_savememory, self).__init__(nInputChannels=nInputChannels, n_classes=n_classes,
+                                                                                   os=os, )
+        ### source graph
+        # self.source_featuremap_2_graph = gcn.Featuremaps_to_Graph(input_channels=input_channels, hidden_layers=hidden_layers,
+        #                                                    nodes=n_classes)
+        # self.source_graph_conv1 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        # self.source_graph_conv2 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        # self.source_graph_conv3 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        #
+        # self.source_graph_2_fea = gcn.Graph_to_Featuremaps(input_channels=input_channels, output_channels=out_channels,
+        #                                             hidden_layers=hidden_layers, nodes=n_classes
+        #                                             )
+        # self.source_skip_conv = nn.Sequential(*[nn.Conv2d(input_channels, input_channels, kernel_size=1),
+        #                                  nn.ReLU(True)])
+
+        ### target graph
+        self.target_featuremap_2_graph = gcn.Featuremaps_to_Graph(input_channels=input_channels, hidden_layers=hidden_layers,
+                                                           nodes=n_classes)
+        self.target_graph_conv1 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.target_graph_conv2 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.target_graph_conv3 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+
+        self.target_graph_2_fea = gcn.Graph_to_Featuremaps_savemem(input_channels=input_channels, output_channels=out_channels,
+                                                                   hidden_layers=hidden_layers, nodes=n_classes
+                                                                   )
+        self.target_skip_conv = nn.Sequential(*[nn.Conv2d(input_channels, input_channels, kernel_size=1),
+                                                nn.BatchNorm2d(input_channels),
+                                                nn.ReLU(True)])
+
+    def load_source_model(self,state_dict):
+        own_state = self.state_dict()
+        # for name inshop_cos own_state:
+        #    print name
+        new_state_dict = OrderedDict()
+        for name, param in state_dict.items():
+            name = name.replace('module.', '')
+
+            if 'graph' in name and 'source' not in name and 'target' not in name:
+                if 'featuremap_2_graph' in name:
+                    name = name.replace('featuremap_2_graph','source_featuremap_2_graph')
+                else:
+                    name = name.replace('graph','source_graph')
+            new_state_dict[name] = 0
+            if name not in own_state:
+                if 'num_batch' in name:
+                    continue
+                print('unexpected key "{}" in state_dict'
+                      .format(name))
+                continue
+                # if isinstance(param, own_state):
+            if isinstance(param, Parameter):
+                # backwards compatibility for serialized parameters
+                param = param.data
+            try:
+                own_state[name].copy_(param)
+            except:
+                print('While copying the parameter named {}, whose dimensions in the model are'
+                      ' {} and whose dimensions in the checkpoint are {}, ...'.format(
+                    name, own_state[name].size(), param.size()))
+                continue  # i add inshop_cos 2018/02/01
+            own_state[name].copy_(param)
+            # print 'copying %s' %name
+
+        missing = set(own_state.keys()) - set(new_state_dict.keys())
+        if len(missing) > 0:
+            print('missing keys in state_dict: "{}"'.format(missing))
+
+    def get_target_parameter(self):
+        l = []
+        other = []
+        for name, k in self.named_parameters():
+            if 'target' in name or 'semantic' in name:
+                l.append(k)
+            else:
+                other.append(k)
+        return l, other
+
+    def get_semantic_parameter(self):
+        l = []
+        for name, k in self.named_parameters():
+            if 'semantic' in name:
+                l.append(k)
+        return l
+
+    def get_source_parameter(self):
+        l = []
+        for name, k in self.named_parameters():
+            if 'source' in name:
+                l.append(k)
+        return l
+
+    def forward(self, input,adj1_target=None, adj2_source=None,adj3_transfer=None ):
+        x, low_level_features = self.xception_features(input)
+        # print(x.size())
+        x1 = self.aspp1(x)
+        x2 = self.aspp2(x)
+        x3 = self.aspp3(x)
+        x4 = self.aspp4(x)
+        x5 = self.global_avg_pool(x)
+        x5 = F.upsample(x5, size=x4.size()[2:], mode='bilinear', align_corners=True)
+
+        x = torch.cat((x1, x2, x3, x4, x5), dim=1)
+
+        x = self.concat_projection_conv1(x)
+        x = self.concat_projection_bn1(x)
+        x = self.relu(x)
+        # print(x.size())
+        x = F.upsample(x, size=low_level_features.size()[2:], mode='bilinear', align_corners=True)
+
+        low_level_features = self.feature_projection_conv1(low_level_features)
+        low_level_features = self.feature_projection_bn1(low_level_features)
+        low_level_features = self.relu(low_level_features)
+        # print(low_level_features.size())
+        # print(x.size())
+        x = torch.cat((x, low_level_features), dim=1)
+        x = self.decoder(x)
+
+        ### add graph
+
+
+        # target graph
+        # print('x size',x.size(),adj1.size())
+        graph = self.target_featuremap_2_graph(x)
+
+        # graph combine
+        # print(graph.size(),source_2_target_graph.size())
+        # graph = self.fc_graph.forward(graph,relu=True)
+        # print(graph.size())
+
+        graph = self.target_graph_conv1.forward(graph, adj=adj1_target, relu=True)
+        graph = self.target_graph_conv2.forward(graph, adj=adj1_target, relu=True)
+        graph = self.target_graph_conv3.forward(graph, adj=adj1_target, relu=True)
+        # print(graph.size(),x.size())
+        # graph = self.gcn_encode.forward(graph,relu=True)
+        # graph = self.graph_conv2.forward(graph,adj=adj2,relu=True)
+        # graph = self.gcn_decode.forward(graph,relu=True)
+        graph = self.target_graph_2_fea.forward(graph, x)
+        x = self.target_skip_conv(x)
+        x = x + graph
+
+        ###
+        x = self.semantic(x)
+        x = F.upsample(x, size=input.size()[2:], mode='bilinear', align_corners=True)
+
+        return x
+
+#######################
+# transfer model
+#######################
+
+class deeplab_xception_transfer_projection(deeplab_xception_transfer_basemodel):
+    def __init__(self, nInputChannels=3, n_classes=7, os=16,input_channels=256,hidden_layers=128,out_channels=256,
+                 transfer_graph=None, source_classes=20):
+        super(deeplab_xception_transfer_projection, self).__init__(nInputChannels=nInputChannels, n_classes=n_classes,
+                                                                   os=os, input_channels=input_channels,
+                                                                   hidden_layers=hidden_layers, out_channels=out_channels, )
+        self.source_featuremap_2_graph = gcn.Featuremaps_to_Graph(input_channels=input_channels, hidden_layers=hidden_layers,
+                                                           nodes=source_classes)
+        self.source_graph_conv1 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.source_graph_conv2 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.source_graph_conv3 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.transpose_graph = gcn.Graph_trans(in_features=hidden_layers,out_features=hidden_layers,adj=transfer_graph,
+                                               begin_nodes=source_classes,end_nodes=n_classes)
+        self.fc_graph = gcn.GraphConvolution(hidden_layers*3, hidden_layers)
+
+    def forward(self, input,adj1_target=None, adj2_source=None,adj3_transfer=None ):
+        x, low_level_features = self.xception_features(input)
+        # print(x.size())
+        x1 = self.aspp1(x)
+        x2 = self.aspp2(x)
+        x3 = self.aspp3(x)
+        x4 = self.aspp4(x)
+        x5 = self.global_avg_pool(x)
+        x5 = F.upsample(x5, size=x4.size()[2:], mode='bilinear', align_corners=True)
+
+        x = torch.cat((x1, x2, x3, x4, x5), dim=1)
+
+        x = self.concat_projection_conv1(x)
+        x = self.concat_projection_bn1(x)
+        x = self.relu(x)
+        # print(x.size())
+        x = F.upsample(x, size=low_level_features.size()[2:], mode='bilinear', align_corners=True)
+
+        low_level_features = self.feature_projection_conv1(low_level_features)
+        low_level_features = self.feature_projection_bn1(low_level_features)
+        low_level_features = self.relu(low_level_features)
+        # print(low_level_features.size())
+        # print(x.size())
+        x = torch.cat((x, low_level_features), dim=1)
+        x = self.decoder(x)
+
+        ### add graph
+        # source graph
+        source_graph = self.source_featuremap_2_graph(x)
+        source_graph1 = self.source_graph_conv1.forward(source_graph,adj=adj2_source, relu=True)
+        source_graph2 = self.source_graph_conv2.forward(source_graph1, adj=adj2_source, relu=True)
+        source_graph3 = self.source_graph_conv2.forward(source_graph2, adj=adj2_source, relu=True)
+
+        source_2_target_graph1_v5 = self.transpose_graph.forward(source_graph1, adj=adj3_transfer, relu=True)
+        source_2_target_graph2_v5 = self.transpose_graph.forward(source_graph2, adj=adj3_transfer, relu=True)
+        source_2_target_graph3_v5 = self.transpose_graph.forward(source_graph3, adj=adj3_transfer, relu=True)
+
+        # target graph
+        # print('x size',x.size(),adj1.size())
+        graph = self.target_featuremap_2_graph(x)
+
+        source_2_target_graph1 = self.similarity_trans(source_graph1, graph)
+        # graph combine 1
+        # print(graph.size())
+        # print(source_2_target_graph1.size())
+        # print(source_2_target_graph1_v5.size())
+        graph = torch.cat((graph,source_2_target_graph1.squeeze(0), source_2_target_graph1_v5.squeeze(0)),dim=-1)
+        graph = self.fc_graph.forward(graph,relu=True)
+
+        graph = self.target_graph_conv1.forward(graph, adj=adj1_target, relu=True)
+
+        source_2_target_graph2 = self.similarity_trans(source_graph2, graph)
+        # graph combine 2
+        graph = torch.cat((graph, source_2_target_graph2, source_2_target_graph2_v5), dim=-1)
+        graph = self.fc_graph.forward(graph, relu=True)
+
+        graph = self.target_graph_conv2.forward(graph, adj=adj1_target, relu=True)
+
+        source_2_target_graph3 = self.similarity_trans(source_graph3, graph)
+        # graph combine 3
+        graph = torch.cat((graph, source_2_target_graph3, source_2_target_graph3_v5), dim=-1)
+        graph = self.fc_graph.forward(graph, relu=True)
+
+        graph = self.target_graph_conv3.forward(graph, adj=adj1_target, relu=True)
+
+        # print(graph.size(),x.size())
+
+        graph = self.target_graph_2_fea.forward(graph, x)
+        x = self.target_skip_conv(x)
+        x = x + graph
+
+        ###
+        x = self.semantic(x)
+        x = F.upsample(x, size=input.size()[2:], mode='bilinear', align_corners=True)
+
+        return x
+
+    def similarity_trans(self,source,target):
+        sim = torch.matmul(F.normalize(target, p=2, dim=-1), F.normalize(source, p=2, dim=-1).transpose(-1, -2))
+        sim = F.softmax(sim, dim=-1)
+        return torch.matmul(sim, source)
+
+    def load_source_model(self,state_dict):
+        own_state = self.state_dict()
+        # for name inshop_cos own_state:
+        #    print name
+        new_state_dict = OrderedDict()
+        for name, param in state_dict.items():
+            name = name.replace('module.', '')
+
+            if 'graph' in name and 'source' not in name and 'target' not in name and 'fc_' not in name and 'transpose_graph' not in name:
+                if 'featuremap_2_graph' in name:
+                    name = name.replace('featuremap_2_graph','source_featuremap_2_graph')
+                else:
+                    name = name.replace('graph','source_graph')
+            new_state_dict[name] = 0
+            if name not in own_state:
+                if 'num_batch' in name:
+                    continue
+                print('unexpected key "{}" in state_dict'
+                      .format(name))
+                continue
+                # if isinstance(param, own_state):
+            if isinstance(param, Parameter):
+                # backwards compatibility for serialized parameters
+                param = param.data
+            try:
+                own_state[name].copy_(param)
+            except:
+                print('While copying the parameter named {}, whose dimensions in the model are'
+                      ' {} and whose dimensions in the checkpoint are {}, ...'.format(
+                    name, own_state[name].size(), param.size()))
+                continue  # i add inshop_cos 2018/02/01
+            own_state[name].copy_(param)
+            # print 'copying %s' %name
+
+        missing = set(own_state.keys()) - set(new_state_dict.keys())
+        if len(missing) > 0:
+            print('missing keys in state_dict: "{}"'.format(missing))
+
+class deeplab_xception_transfer_projection_savemem(deeplab_xception_transfer_basemodel_savememory):
+    def __init__(self, nInputChannels=3, n_classes=7, os=16,input_channels=256,hidden_layers=128,out_channels=256,
+                 transfer_graph=None, source_classes=20):
+        super(deeplab_xception_transfer_projection_savemem, self).__init__(nInputChannels=nInputChannels, n_classes=n_classes,
+                                                                           os=os, input_channels=input_channels,
+                                                                           hidden_layers=hidden_layers, out_channels=out_channels, )
+        self.source_featuremap_2_graph = gcn.Featuremaps_to_Graph(input_channels=input_channels, hidden_layers=hidden_layers,
+                                                           nodes=source_classes)
+        self.source_graph_conv1 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.source_graph_conv2 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.source_graph_conv3 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.transpose_graph = gcn.Graph_trans(in_features=hidden_layers,out_features=hidden_layers,adj=transfer_graph,
+                                               begin_nodes=source_classes,end_nodes=n_classes)
+        self.fc_graph = gcn.GraphConvolution(hidden_layers*3, hidden_layers)
+
+    def forward(self, input,adj1_target=None, adj2_source=None,adj3_transfer=None ):
+        x, low_level_features = self.xception_features(input)
+        # print(x.size())
+        x1 = self.aspp1(x)
+        x2 = self.aspp2(x)
+        x3 = self.aspp3(x)
+        x4 = self.aspp4(x)
+        x5 = self.global_avg_pool(x)
+        x5 = F.upsample(x5, size=x4.size()[2:], mode='bilinear', align_corners=True)
+
+        x = torch.cat((x1, x2, x3, x4, x5), dim=1)
+
+        x = self.concat_projection_conv1(x)
+        x = self.concat_projection_bn1(x)
+        x = self.relu(x)
+        # print(x.size())
+        x = F.upsample(x, size=low_level_features.size()[2:], mode='bilinear', align_corners=True)
+
+        low_level_features = self.feature_projection_conv1(low_level_features)
+        low_level_features = self.feature_projection_bn1(low_level_features)
+        low_level_features = self.relu(low_level_features)
+        # print(low_level_features.size())
+        # print(x.size())
+        x = torch.cat((x, low_level_features), dim=1)
+        x = self.decoder(x)
+
+        ### add graph
+        # source graph
+        source_graph = self.source_featuremap_2_graph(x)
+        source_graph1 = self.source_graph_conv1.forward(source_graph,adj=adj2_source, relu=True)
+        source_graph2 = self.source_graph_conv2.forward(source_graph1, adj=adj2_source, relu=True)
+        source_graph3 = self.source_graph_conv2.forward(source_graph2, adj=adj2_source, relu=True)
+
+        source_2_target_graph1_v5 = self.transpose_graph.forward(source_graph1, adj=adj3_transfer, relu=True)
+        source_2_target_graph2_v5 = self.transpose_graph.forward(source_graph2, adj=adj3_transfer, relu=True)
+        source_2_target_graph3_v5 = self.transpose_graph.forward(source_graph3, adj=adj3_transfer, relu=True)
+
+        # target graph
+        # print('x size',x.size(),adj1.size())
+        graph = self.target_featuremap_2_graph(x)
+
+        source_2_target_graph1 = self.similarity_trans(source_graph1, graph)
+        # graph combine 1
+        graph = torch.cat((graph,source_2_target_graph1.squeeze(0), source_2_target_graph1_v5.squeeze(0)),dim=-1)
+        graph = self.fc_graph.forward(graph,relu=True)
+
+        graph = self.target_graph_conv1.forward(graph, adj=adj1_target, relu=True)
+
+        source_2_target_graph2 = self.similarity_trans(source_graph2, graph)
+        # graph combine 2
+        graph = torch.cat((graph, source_2_target_graph2, source_2_target_graph2_v5), dim=-1)
+        graph = self.fc_graph.forward(graph, relu=True)
+
+        graph = self.target_graph_conv2.forward(graph, adj=adj1_target, relu=True)
+
+        source_2_target_graph3 = self.similarity_trans(source_graph3, graph)
+        # graph combine 3
+        graph = torch.cat((graph, source_2_target_graph3, source_2_target_graph3_v5), dim=-1)
+        graph = self.fc_graph.forward(graph, relu=True)
+
+        graph = self.target_graph_conv3.forward(graph, adj=adj1_target, relu=True)
+
+        # print(graph.size(),x.size())
+
+        graph = self.target_graph_2_fea.forward(graph, x)
+        x = self.target_skip_conv(x)
+        x = x + graph
+
+        ###
+        x = self.semantic(x)
+        x = F.upsample(x, size=input.size()[2:], mode='bilinear', align_corners=True)
+
+        return x
+
+    def similarity_trans(self,source,target):
+        sim = torch.matmul(F.normalize(target, p=2, dim=-1), F.normalize(source, p=2, dim=-1).transpose(-1, -2))
+        sim = F.softmax(sim, dim=-1)
+        return torch.matmul(sim, source)
+
+    def load_source_model(self,state_dict):
+        own_state = self.state_dict()
+        # for name inshop_cos own_state:
+        #    print name
+        new_state_dict = OrderedDict()
+        for name, param in state_dict.items():
+            name = name.replace('module.', '')
+
+            if 'graph' in name and 'source' not in name and 'target' not in name and 'fc_' not in name and 'transpose_graph' not in name:
+                if 'featuremap_2_graph' in name:
+                    name = name.replace('featuremap_2_graph','source_featuremap_2_graph')
+                else:
+                    name = name.replace('graph','source_graph')
+            new_state_dict[name] = 0
+            if name not in own_state:
+                if 'num_batch' in name:
+                    continue
+                print('unexpected key "{}" in state_dict'
+                      .format(name))
+                continue
+                # if isinstance(param, own_state):
+            if isinstance(param, Parameter):
+                # backwards compatibility for serialized parameters
+                param = param.data
+            try:
+                own_state[name].copy_(param)
+            except:
+                print('While copying the parameter named {}, whose dimensions in the model are'
+                      ' {} and whose dimensions in the checkpoint are {}, ...'.format(
+                    name, own_state[name].size(), param.size()))
+                continue  # i add inshop_cos 2018/02/01
+            own_state[name].copy_(param)
+            # print 'copying %s' %name
+
+        missing = set(own_state.keys()) - set(new_state_dict.keys())
+        if len(missing) > 0:
+            print('missing keys in state_dict: "{}"'.format(missing))
+
+
+class deeplab_xception_transfer_projection_synBN_savemem(deeplab_xception_transfer_basemodel_synBN_savememory):
+    def __init__(self, nInputChannels=3, n_classes=7, os=16,input_channels=256,hidden_layers=128,out_channels=256,
+                 transfer_graph=None, source_classes=20):
+        super(deeplab_xception_transfer_projection_synBN_savemem, self).__init__(nInputChannels=nInputChannels, n_classes=n_classes,
+                                                                                 os=os, input_channels=input_channels,
+                                                                                 hidden_layers=hidden_layers, out_channels=out_channels, )
+        self.source_featuremap_2_graph = gcn.Featuremaps_to_Graph(input_channels=input_channels, hidden_layers=hidden_layers,
+                                                           nodes=source_classes)
+        self.source_graph_conv1 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.source_graph_conv2 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.source_graph_conv3 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.transpose_graph = gcn.Graph_trans(in_features=hidden_layers,out_features=hidden_layers,adj=transfer_graph,
+                                               begin_nodes=source_classes,end_nodes=n_classes)
+        self.fc_graph = gcn.GraphConvolution(hidden_layers*3 ,hidden_layers)
+
+    def forward(self, input,adj1_target=None, adj2_source=None,adj3_transfer=None ):
+        x, low_level_features = self.xception_features(input)
+        # print(x.size())
+        x1 = self.aspp1(x)
+        x2 = self.aspp2(x)
+        x3 = self.aspp3(x)
+        x4 = self.aspp4(x)
+        x5 = self.global_avg_pool(x)
+        x5 = F.upsample(x5, size=x4.size()[2:], mode='bilinear', align_corners=True)
+
+        x = torch.cat((x1, x2, x3, x4, x5), dim=1)
+
+        x = self.concat_projection_conv1(x)
+        x = self.concat_projection_bn1(x)
+        x = self.relu(x)
+        # print(x.size())
+        x = F.upsample(x, size=low_level_features.size()[2:], mode='bilinear', align_corners=True)
+
+        low_level_features = self.feature_projection_conv1(low_level_features)
+        low_level_features = self.feature_projection_bn1(low_level_features)
+        low_level_features = self.relu(low_level_features)
+        # print(low_level_features.size())
+        # print(x.size())
+        x = torch.cat((x, low_level_features), dim=1)
+        x = self.decoder(x)
+
+        ### add graph
+        # source graph
+        source_graph = self.source_featuremap_2_graph(x)
+        source_graph1 = self.source_graph_conv1.forward(source_graph,adj=adj2_source, relu=True)
+        source_graph2 = self.source_graph_conv2.forward(source_graph1, adj=adj2_source, relu=True)
+        source_graph3 = self.source_graph_conv2.forward(source_graph2, adj=adj2_source, relu=True)
+
+        source_2_target_graph1_v5 = self.transpose_graph.forward(source_graph1, adj=adj3_transfer, relu=True)
+        source_2_target_graph2_v5 = self.transpose_graph.forward(source_graph2, adj=adj3_transfer, relu=True)
+        source_2_target_graph3_v5 = self.transpose_graph.forward(source_graph3, adj=adj3_transfer, relu=True)
+
+        # target graph
+        # print('x size',x.size(),adj1.size())
+        graph = self.target_featuremap_2_graph(x)
+
+        source_2_target_graph1 = self.similarity_trans(source_graph1, graph)
+        # graph combine 1
+        graph = torch.cat((graph,source_2_target_graph1.squeeze(0), source_2_target_graph1_v5.squeeze(0)),dim=-1)
+        graph = self.fc_graph.forward(graph,relu=True)
+
+        graph = self.target_graph_conv1.forward(graph, adj=adj1_target, relu=True)
+
+        source_2_target_graph2 = self.similarity_trans(source_graph2, graph)
+        # graph combine 2
+        graph = torch.cat((graph, source_2_target_graph2, source_2_target_graph2_v5), dim=-1)
+        graph = self.fc_graph.forward(graph, relu=True)
+
+        graph = self.target_graph_conv2.forward(graph, adj=adj1_target, relu=True)
+
+        source_2_target_graph3 = self.similarity_trans(source_graph3, graph)
+        # graph combine 3
+        graph = torch.cat((graph, source_2_target_graph3, source_2_target_graph3_v5), dim=-1)
+        graph = self.fc_graph.forward(graph, relu=True)
+
+        graph = self.target_graph_conv3.forward(graph, adj=adj1_target, relu=True)
+
+        # print(graph.size(),x.size())
+
+        graph = self.target_graph_2_fea.forward(graph, x)
+        x = self.target_skip_conv(x)
+        x = x + graph
+
+        ###
+        x = self.semantic(x)
+        x = F.upsample(x, size=input.size()[2:], mode='bilinear', align_corners=True)
+
+        return x
+
+    def similarity_trans(self,source,target):
+        sim = torch.matmul(F.normalize(target, p=2, dim=-1), F.normalize(source, p=2, dim=-1).transpose(-1, -2))
+        sim = F.softmax(sim, dim=-1)
+        return torch.matmul(sim, source)
+
+    def load_source_model(self,state_dict):
+        own_state = self.state_dict()
+        # for name inshop_cos own_state:
+        #    print name
+        new_state_dict = OrderedDict()
+        for name, param in state_dict.items():
+            name = name.replace('module.', '')
+
+            if 'graph' in name and 'source' not in name and 'target' not in name and 'fc_' not in name and 'transpose_graph' not in name:
+                if 'featuremap_2_graph' in name:
+                    name = name.replace('featuremap_2_graph','source_featuremap_2_graph')
+                else:
+                    name = name.replace('graph','source_graph')
+            new_state_dict[name] = 0
+            if name not in own_state:
+                if 'num_batch' in name:
+                    continue
+                print('unexpected key "{}" in state_dict'
+                      .format(name))
+                continue
+                # if isinstance(param, own_state):
+            if isinstance(param, Parameter):
+                # backwards compatibility for serialized parameters
+                param = param.data
+            try:
+                own_state[name].copy_(param)
+            except:
+                print('While copying the parameter named {}, whose dimensions in the model are'
+                      ' {} and whose dimensions in the checkpoint are {}, ...'.format(
+                    name, own_state[name].size(), param.size()))
+                continue  # i add inshop_cos 2018/02/01
+            own_state[name].copy_(param)
+            # print 'copying %s' %name
+
+        missing = set(own_state.keys()) - set(new_state_dict.keys())
+        if len(missing) > 0:
+            print('missing keys in state_dict: "{}"'.format(missing))
+
+
+# if __name__ == '__main__':
+    # net = deeplab_xception_transfer_projection_v3v5_more_savemem()
+    # img = torch.rand((2,3,128,128))
+    # net.eval()
+    # a = torch.rand((1,1,7,7))
+    # net.forward(img, adj1_target=a)

TryYours-Virtual-Try-On/Graphonomy-master/networks/deeplab_xception_universal.py

@@ -0,0 +1,1077 @@
+import math
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from collections import OrderedDict
+from torch.nn import Parameter
+from networks import deeplab_xception, gcn, deeplab_xception_synBN
+
+
+
+class deeplab_xception_transfer_basemodel_savememory(deeplab_xception.DeepLabv3_plus):
+    def __init__(self, nInputChannels=3, n_classes=7, os=16, input_channels=256, hidden_layers=128, out_channels=256,
+                 source_classes=20, transfer_graph=None):
+        super(deeplab_xception_transfer_basemodel_savememory, self).__init__(nInputChannels=nInputChannels, n_classes=n_classes,
+                                                                  os=os,)
+
+    def load_source_model(self,state_dict):
+        own_state = self.state_dict()
+        # for name inshop_cos own_state:
+        #    print name
+        new_state_dict = OrderedDict()
+        for name, param in state_dict.items():
+            name = name.replace('module.', '')
+            if 'graph' in name and 'source' not in name and 'target' not in name and 'fc_graph' not in name \
+                    and 'transpose_graph' not in name and 'middle' not in name:
+                if 'featuremap_2_graph' in name:
+                    name = name.replace('featuremap_2_graph','source_featuremap_2_graph')
+                else:
+                    name = name.replace('graph','source_graph')
+            new_state_dict[name] = 0
+            if name not in own_state:
+                if 'num_batch' in name:
+                    continue
+                print('unexpected key "{}" in state_dict'
+                      .format(name))
+                continue
+                # if isinstance(param, own_state):
+            if isinstance(param, Parameter):
+                # backwards compatibility for serialized parameters
+                param = param.data
+            try:
+                own_state[name].copy_(param)
+            except:
+                print('While copying the parameter named {}, whose dimensions in the model are'
+                      ' {} and whose dimensions in the checkpoint are {}, ...'.format(
+                    name, own_state[name].size(), param.size()))
+                continue  # i add inshop_cos 2018/02/01
+            own_state[name].copy_(param)
+            # print 'copying %s' %name
+
+        missing = set(own_state.keys()) - set(new_state_dict.keys())
+        if len(missing) > 0:
+            print('missing keys in state_dict: "{}"'.format(missing))
+
+    def get_target_parameter(self):
+        l = []
+        other = []
+        for name, k in self.named_parameters():
+            if 'target' in name or 'semantic' in name:
+                l.append(k)
+            else:
+                other.append(k)
+        return l, other
+
+    def get_semantic_parameter(self):
+        l = []
+        for name, k in self.named_parameters():
+            if 'semantic' in name:
+                l.append(k)
+        return l
+
+    def get_source_parameter(self):
+        l = []
+        for name, k in self.named_parameters():
+            if 'source' in name:
+                l.append(k)
+        return l
+
+    def top_forward(self, input, adj1_target=None, adj2_source=None,adj3_transfer=None ):
+        x, low_level_features = self.xception_features(input)
+        # print(x.size())
+        x1 = self.aspp1(x)
+        x2 = self.aspp2(x)
+        x3 = self.aspp3(x)
+        x4 = self.aspp4(x)
+        x5 = self.global_avg_pool(x)
+        x5 = F.upsample(x5, size=x4.size()[2:], mode='bilinear', align_corners=True)
+
+        x = torch.cat((x1, x2, x3, x4, x5), dim=1)
+
+        x = self.concat_projection_conv1(x)
+        x = self.concat_projection_bn1(x)
+        x = self.relu(x)
+        # print(x.size())
+        x = F.upsample(x, size=low_level_features.size()[2:], mode='bilinear', align_corners=True)
+
+        low_level_features = self.feature_projection_conv1(low_level_features)
+        low_level_features = self.feature_projection_bn1(low_level_features)
+        low_level_features = self.relu(low_level_features)
+        # print(low_level_features.size())
+        # print(x.size())
+        x = torch.cat((x, low_level_features), dim=1)
+        x = self.decoder(x)
+
+        ### source graph
+        source_graph = self.source_featuremap_2_graph(x)
+
+        source_graph1 = self.source_graph_conv1.forward(source_graph, adj=adj2_source, relu=True)
+        source_graph2 = self.source_graph_conv2.forward(source_graph1, adj=adj2_source, relu=True)
+        source_graph3 = self.source_graph_conv2.forward(source_graph2, adj=adj2_source, relu=True)
+
+        ### target source
+        graph = self.target_featuremap_2_graph(x)
+
+        # graph combine
+        # print(graph.size(),source_2_target_graph.size())
+        # graph = self.fc_graph.forward(graph,relu=True)
+        # print(graph.size())
+
+        graph = self.target_graph_conv1.forward(graph, adj=adj1_target, relu=True)
+        graph = self.target_graph_conv2.forward(graph, adj=adj1_target, relu=True)
+        graph = self.target_graph_conv3.forward(graph, adj=adj1_target, relu=True)
+
+
+    def forward(self, input,adj1_target=None, adj2_source=None,adj3_transfer=None ):
+        x, low_level_features = self.xception_features(input)
+        # print(x.size())
+        x1 = self.aspp1(x)
+        x2 = self.aspp2(x)
+        x3 = self.aspp3(x)
+        x4 = self.aspp4(x)
+        x5 = self.global_avg_pool(x)
+        x5 = F.upsample(x5, size=x4.size()[2:], mode='bilinear', align_corners=True)
+
+        x = torch.cat((x1, x2, x3, x4, x5), dim=1)
+
+        x = self.concat_projection_conv1(x)
+        x = self.concat_projection_bn1(x)
+        x = self.relu(x)
+        # print(x.size())
+        x = F.upsample(x, size=low_level_features.size()[2:], mode='bilinear', align_corners=True)
+
+        low_level_features = self.feature_projection_conv1(low_level_features)
+        low_level_features = self.feature_projection_bn1(low_level_features)
+        low_level_features = self.relu(low_level_features)
+        # print(low_level_features.size())
+        # print(x.size())
+        x = torch.cat((x, low_level_features), dim=1)
+        x = self.decoder(x)
+
+        ### add graph
+
+
+        # target graph
+        # print('x size',x.size(),adj1.size())
+        graph = self.target_featuremap_2_graph(x)
+
+        # graph combine
+        # print(graph.size(),source_2_target_graph.size())
+        # graph = self.fc_graph.forward(graph,relu=True)
+        # print(graph.size())
+
+        graph = self.target_graph_conv1.forward(graph, adj=adj1_target, relu=True)
+        graph = self.target_graph_conv2.forward(graph, adj=adj1_target, relu=True)
+        graph = self.target_graph_conv3.forward(graph, adj=adj1_target, relu=True)
+        # print(graph.size(),x.size())
+        # graph = self.gcn_encode.forward(graph,relu=True)
+        # graph = self.graph_conv2.forward(graph,adj=adj2,relu=True)
+        # graph = self.gcn_decode.forward(graph,relu=True)
+        graph = self.target_graph_2_fea.forward(graph, x)
+        x = self.target_skip_conv(x)
+        x = x + graph
+
+        ###
+        x = self.semantic(x)
+        x = F.upsample(x, size=input.size()[2:], mode='bilinear', align_corners=True)
+
+        return x
+
+
+class deeplab_xception_transfer_basemodel_savememory_synbn(deeplab_xception_synBN.DeepLabv3_plus):
+    def __init__(self, nInputChannels=3, n_classes=7, os=16, input_channels=256, hidden_layers=128, out_channels=256,
+                 source_classes=20, transfer_graph=None):
+        super(deeplab_xception_transfer_basemodel_savememory_synbn, self).__init__(nInputChannels=nInputChannels, n_classes=n_classes,
+                                                                  os=os,)
+
+
+    def load_source_model(self,state_dict):
+        own_state = self.state_dict()
+        # for name inshop_cos own_state:
+        #    print name
+        new_state_dict = OrderedDict()
+        for name, param in state_dict.items():
+            name = name.replace('module.', '')
+            if 'graph' in name and 'source' not in name and 'target' not in name and 'fc_graph' not in name \
+                    and 'transpose_graph' not in name and 'middle' not in name:
+                if 'featuremap_2_graph' in name:
+                    name = name.replace('featuremap_2_graph','source_featuremap_2_graph')
+                else:
+                    name = name.replace('graph','source_graph')
+            new_state_dict[name] = 0
+            if name not in own_state:
+                if 'num_batch' in name:
+                    continue
+                print('unexpected key "{}" in state_dict'
+                      .format(name))
+                continue
+                # if isinstance(param, own_state):
+            if isinstance(param, Parameter):
+                # backwards compatibility for serialized parameters
+                param = param.data
+            try:
+                own_state[name].copy_(param)
+            except:
+                print('While copying the parameter named {}, whose dimensions in the model are'
+                      ' {} and whose dimensions in the checkpoint are {}, ...'.format(
+                    name, own_state[name].size(), param.size()))
+                continue  # i add inshop_cos 2018/02/01
+            own_state[name].copy_(param)
+            # print 'copying %s' %name
+
+        missing = set(own_state.keys()) - set(new_state_dict.keys())
+        if len(missing) > 0:
+            print('missing keys in state_dict: "{}"'.format(missing))
+
+    def get_target_parameter(self):
+        l = []
+        other = []
+        for name, k in self.named_parameters():
+            if 'target' in name or 'semantic' in name:
+                l.append(k)
+            else:
+                other.append(k)
+        return l, other
+
+    def get_semantic_parameter(self):
+        l = []
+        for name, k in self.named_parameters():
+            if 'semantic' in name:
+                l.append(k)
+        return l
+
+    def get_source_parameter(self):
+        l = []
+        for name, k in self.named_parameters():
+            if 'source' in name:
+                l.append(k)
+        return l
+
+    def top_forward(self, input, adj1_target=None, adj2_source=None,adj3_transfer=None ):
+        x, low_level_features = self.xception_features(input)
+        # print(x.size())
+        x1 = self.aspp1(x)
+        x2 = self.aspp2(x)
+        x3 = self.aspp3(x)
+        x4 = self.aspp4(x)
+        x5 = self.global_avg_pool(x)
+        x5 = F.upsample(x5, size=x4.size()[2:], mode='bilinear', align_corners=True)
+
+        x = torch.cat((x1, x2, x3, x4, x5), dim=1)
+
+        x = self.concat_projection_conv1(x)
+        x = self.concat_projection_bn1(x)
+        x = self.relu(x)
+        # print(x.size())
+        x = F.upsample(x, size=low_level_features.size()[2:], mode='bilinear', align_corners=True)
+
+        low_level_features = self.feature_projection_conv1(low_level_features)
+        low_level_features = self.feature_projection_bn1(low_level_features)
+        low_level_features = self.relu(low_level_features)
+        # print(low_level_features.size())
+        # print(x.size())
+        x = torch.cat((x, low_level_features), dim=1)
+        x = self.decoder(x)
+
+        ### source graph
+        source_graph = self.source_featuremap_2_graph(x)
+
+        source_graph1 = self.source_graph_conv1.forward(source_graph, adj=adj2_source, relu=True)
+        source_graph2 = self.source_graph_conv2.forward(source_graph1, adj=adj2_source, relu=True)
+        source_graph3 = self.source_graph_conv2.forward(source_graph2, adj=adj2_source, relu=True)
+
+        ### target source
+        graph = self.target_featuremap_2_graph(x)
+
+        # graph combine
+        # print(graph.size(),source_2_target_graph.size())
+        # graph = self.fc_graph.forward(graph,relu=True)
+        # print(graph.size())
+
+        graph = self.target_graph_conv1.forward(graph, adj=adj1_target, relu=True)
+        graph = self.target_graph_conv2.forward(graph, adj=adj1_target, relu=True)
+        graph = self.target_graph_conv3.forward(graph, adj=adj1_target, relu=True)
+
+
+    def forward(self, input,adj1_target=None, adj2_source=None,adj3_transfer=None ):
+        x, low_level_features = self.xception_features(input)
+        # print(x.size())
+        x1 = self.aspp1(x)
+        x2 = self.aspp2(x)
+        x3 = self.aspp3(x)
+        x4 = self.aspp4(x)
+        x5 = self.global_avg_pool(x)
+        x5 = F.upsample(x5, size=x4.size()[2:], mode='bilinear', align_corners=True)
+
+        x = torch.cat((x1, x2, x3, x4, x5), dim=1)
+
+        x = self.concat_projection_conv1(x)
+        x = self.concat_projection_bn1(x)
+        x = self.relu(x)
+        # print(x.size())
+        x = F.upsample(x, size=low_level_features.size()[2:], mode='bilinear', align_corners=True)
+
+        low_level_features = self.feature_projection_conv1(low_level_features)
+        low_level_features = self.feature_projection_bn1(low_level_features)
+        low_level_features = self.relu(low_level_features)
+        # print(low_level_features.size())
+        # print(x.size())
+        x = torch.cat((x, low_level_features), dim=1)
+        x = self.decoder(x)
+
+        ### add graph
+
+
+        # target graph
+        # print('x size',x.size(),adj1.size())
+        graph = self.target_featuremap_2_graph(x)
+
+        # graph combine
+        # print(graph.size(),source_2_target_graph.size())
+        # graph = self.fc_graph.forward(graph,relu=True)
+        # print(graph.size())
+
+        graph = self.target_graph_conv1.forward(graph, adj=adj1_target, relu=True)
+        graph = self.target_graph_conv2.forward(graph, adj=adj1_target, relu=True)
+        graph = self.target_graph_conv3.forward(graph, adj=adj1_target, relu=True)
+        # print(graph.size(),x.size())
+        # graph = self.gcn_encode.forward(graph,relu=True)
+        # graph = self.graph_conv2.forward(graph,adj=adj2,relu=True)
+        # graph = self.gcn_decode.forward(graph,relu=True)
+        graph = self.target_graph_2_fea.forward(graph, x)
+        x = self.target_skip_conv(x)
+        x = x + graph
+
+        ###
+        x = self.semantic(x)
+        x = F.upsample(x, size=input.size()[2:], mode='bilinear', align_corners=True)
+
+        return x
+
+
+class deeplab_xception_end2end_3d(deeplab_xception_transfer_basemodel_savememory):
+    def __init__(self, nInputChannels=3, n_classes=20, os=16, input_channels=256, hidden_layers=128, out_channels=256,
+                 source_classes=7, middle_classes=18, transfer_graph=None):
+        super(deeplab_xception_end2end_3d, self).__init__(nInputChannels=nInputChannels,
+                                                          n_classes=n_classes,
+                                                          os=os, )
+        ### source graph
+        self.source_featuremap_2_graph = gcn.Featuremaps_to_Graph(input_channels=input_channels,
+                                                                  hidden_layers=hidden_layers,
+                                                                  nodes=source_classes)
+        self.source_graph_conv1 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.source_graph_conv2 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.source_graph_conv3 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+
+        self.source_graph_2_fea = gcn.Graph_to_Featuremaps_savemem(input_channels=input_channels,
+                                                                   output_channels=out_channels,
+                                                                   hidden_layers=hidden_layers, nodes=source_classes
+                                                                   )
+        self.source_skip_conv = nn.Sequential(*[nn.Conv2d(input_channels, input_channels, kernel_size=1),
+                                                nn.ReLU(True)])
+        self.source_semantic = nn.Conv2d(out_channels,source_classes,1)
+        self.middle_semantic = nn.Conv2d(out_channels, middle_classes, 1)
+
+        ### target graph 1
+        self.target_featuremap_2_graph = gcn.Featuremaps_to_Graph(input_channels=input_channels,
+                                                                  hidden_layers=hidden_layers,
+                                                                  nodes=n_classes)
+        self.target_graph_conv1 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.target_graph_conv2 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.target_graph_conv3 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+
+        self.target_graph_2_fea = gcn.Graph_to_Featuremaps_savemem(input_channels=input_channels,
+                                                                   output_channels=out_channels,
+                                                                   hidden_layers=hidden_layers, nodes=n_classes
+                                                                   )
+        self.target_skip_conv = nn.Sequential(*[nn.Conv2d(input_channels, input_channels, kernel_size=1),
+                                                nn.ReLU(True)])
+
+        ### middle
+        self.middle_featuremap_2_graph = gcn.Featuremaps_to_Graph(input_channels=input_channels,
+                                                                  hidden_layers=hidden_layers,
+                                                                  nodes=middle_classes)
+        self.middle_graph_conv1 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.middle_graph_conv2 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.middle_graph_conv3 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+
+        self.middle_graph_2_fea = gcn.Graph_to_Featuremaps_savemem(input_channels=input_channels,
+                                                                   output_channels=out_channels,
+                                                                   hidden_layers=hidden_layers, nodes=n_classes
+                                                                   )
+        self.middle_skip_conv = nn.Sequential(*[nn.Conv2d(input_channels, input_channels, kernel_size=1),
+                                                nn.ReLU(True)])
+
+        ### multi transpose
+        self.transpose_graph_source2target = gcn.Graph_trans(in_features=hidden_layers, out_features=hidden_layers,
+                                                             adj=transfer_graph,
+                                                             begin_nodes=source_classes, end_nodes=n_classes)
+        self.transpose_graph_target2source = gcn.Graph_trans(in_features=hidden_layers, out_features=hidden_layers,
+                                                             adj=transfer_graph,
+                                                             begin_nodes=n_classes, end_nodes=source_classes)
+
+        self.transpose_graph_middle2source = gcn.Graph_trans(in_features=hidden_layers, out_features=hidden_layers,
+                                                             adj=transfer_graph,
+                                                             begin_nodes=middle_classes, end_nodes=source_classes)
+        self.transpose_graph_middle2target = gcn.Graph_trans(in_features=hidden_layers, out_features=hidden_layers,
+                                                             adj=transfer_graph,
+                                                             begin_nodes=middle_classes, end_nodes=source_classes)
+
+        self.transpose_graph_source2middle = gcn.Graph_trans(in_features=hidden_layers, out_features=hidden_layers,
+                                                             adj=transfer_graph,
+                                                             begin_nodes=source_classes, end_nodes=middle_classes)
+        self.transpose_graph_target2middle = gcn.Graph_trans(in_features=hidden_layers, out_features=hidden_layers,
+                                                             adj=transfer_graph,
+                                                             begin_nodes=n_classes, end_nodes=middle_classes)
+
+
+        self.fc_graph_source = gcn.GraphConvolution(hidden_layers * 5, hidden_layers)
+        self.fc_graph_target = gcn.GraphConvolution(hidden_layers * 5, hidden_layers)
+        self.fc_graph_middle = gcn.GraphConvolution(hidden_layers * 5, hidden_layers)
+
+    def freeze_totally_bn(self):
+        for m in self.modules():
+            if isinstance(m, nn.BatchNorm2d):
+                m.eval()
+                m.weight.requires_grad = False
+                m.bias.requires_grad = False
+
+    def freeze_backbone_bn(self):
+        for m in self.xception_features.modules():
+            if isinstance(m, nn.BatchNorm2d):
+                m.eval()
+                m.weight.requires_grad = False
+                m.bias.requires_grad = False
+
+    def top_forward(self, input, adj1_target=None, adj2_source=None, adj3_transfer_s2t=None, adj3_transfer_t2s=None,
+            adj4_middle=None,adj5_transfer_s2m=None,adj6_transfer_t2m=None,adj5_transfer_m2s=None,adj6_transfer_m2t=None,):
+        x, low_level_features = self.xception_features(input)
+        # print(x.size())
+        x1 = self.aspp1(x)
+        x2 = self.aspp2(x)
+        x3 = self.aspp3(x)
+        x4 = self.aspp4(x)
+        x5 = self.global_avg_pool(x)
+        x5 = F.upsample(x5, size=x4.size()[2:], mode='bilinear', align_corners=True)
+
+        x = torch.cat((x1, x2, x3, x4, x5), dim=1)
+
+        x = self.concat_projection_conv1(x)
+        x = self.concat_projection_bn1(x)
+        x = self.relu(x)
+        # print(x.size())
+        x = F.upsample(x, size=low_level_features.size()[2:], mode='bilinear', align_corners=True)
+
+        low_level_features = self.feature_projection_conv1(low_level_features)
+        low_level_features = self.feature_projection_bn1(low_level_features)
+        low_level_features = self.relu(low_level_features)
+        # print(low_level_features.size())
+        # print(x.size())
+        x = torch.cat((x, low_level_features), dim=1)
+        x = self.decoder(x)
+
+        ### source graph
+        source_graph = self.source_featuremap_2_graph(x)
+        ### target source
+        target_graph = self.target_featuremap_2_graph(x)
+        ### middle source
+        middle_graph = self.middle_featuremap_2_graph(x)
+
+        ##### end2end multi task
+
+        ### first task
+        # print(source_graph.size(),target_graph.size())
+        source_graph1 = self.source_graph_conv1.forward(source_graph, adj=adj2_source, relu=True)
+        target_graph1 = self.target_graph_conv1.forward(target_graph, adj=adj1_target, relu=True)
+        middle_graph1 = self.target_graph_conv1.forward(middle_graph, adj=adj4_middle, relu=True)
+
+        # source 2 target & middle
+        source_2_target_graph1_v5 = self.transpose_graph_source2target.forward(source_graph1, adj=adj3_transfer_s2t,
+                                                                               relu=True)
+        source_2_middle_graph1_v5 = self.transpose_graph_source2middle.forward(source_graph1,adj=adj5_transfer_s2m,
+                                                                               relu=True)
+        # target 2 source & middle
+        target_2_source_graph1_v5 = self.transpose_graph_target2source.forward(target_graph1, adj=adj3_transfer_t2s,
+                                                                               relu=True)
+        target_2_middle_graph1_v5 = self.transpose_graph_target2middle.forward(target_graph1, adj=adj6_transfer_t2m,
+                                                                               relu=True)
+        # middle 2 source & target
+        middle_2_source_graph1_v5 = self.transpose_graph_middle2source.forward(middle_graph1, adj=adj5_transfer_m2s,
+                                                                               relu=True)
+        middle_2_target_graph1_v5 = self.transpose_graph_middle2target.forward(middle_graph1, adj=adj6_transfer_m2t,
+                                                                               relu=True)
+        # source 2 middle target
+        source_2_target_graph1 = self.similarity_trans(source_graph1, target_graph1)
+        source_2_middle_graph1 = self.similarity_trans(source_graph1, middle_graph1)
+        # target 2 source middle
+        target_2_source_graph1 = self.similarity_trans(target_graph1, source_graph1)
+        target_2_middle_graph1 = self.similarity_trans(target_graph1, middle_graph1)
+        # middle 2 source target
+        middle_2_source_graph1 = self.similarity_trans(middle_graph1, source_graph1)
+        middle_2_target_graph1 = self.similarity_trans(middle_graph1, target_graph1)
+
+        ## concat
+        # print(source_graph1.size(), target_2_source_graph1.size(), )
+        source_graph1 = torch.cat(
+            (source_graph1, target_2_source_graph1, target_2_source_graph1_v5,
+             middle_2_source_graph1, middle_2_source_graph1_v5), dim=-1)
+        source_graph1 = self.fc_graph_source.forward(source_graph1, relu=True)
+        # target
+        target_graph1 = torch.cat(
+            (target_graph1, source_2_target_graph1, source_2_target_graph1_v5,
+             middle_2_target_graph1, middle_2_target_graph1_v5), dim=-1)
+        target_graph1 = self.fc_graph_target.forward(target_graph1, relu=True)
+        # middle
+        middle_graph1 = torch.cat((middle_graph1, source_2_middle_graph1, source_2_middle_graph1_v5,
+                                   target_2_middle_graph1, target_2_middle_graph1_v5), dim=-1)
+        middle_graph1 = self.fc_graph_middle.forward(middle_graph1, relu=True)
+
+
+        ### seconde task
+        source_graph2 = self.source_graph_conv1.forward(source_graph1, adj=adj2_source, relu=True)
+        target_graph2 = self.target_graph_conv1.forward(target_graph1, adj=adj1_target, relu=True)
+        middle_graph2 = self.target_graph_conv1.forward(middle_graph1, adj=adj4_middle, relu=True)
+
+        # source 2 target & middle
+        source_2_target_graph2_v5 = self.transpose_graph_source2target.forward(source_graph2, adj=adj3_transfer_s2t,
+                                                                               relu=True)
+        source_2_middle_graph2_v5 = self.transpose_graph_source2middle.forward(source_graph2, adj=adj5_transfer_s2m,
+                                                                               relu=True)
+        # target 2 source & middle
+        target_2_source_graph2_v5 = self.transpose_graph_target2source.forward(target_graph2, adj=adj3_transfer_t2s,
+                                                                               relu=True)
+        target_2_middle_graph2_v5 = self.transpose_graph_target2middle.forward(target_graph2, adj=adj6_transfer_t2m,
+                                                                               relu=True)
+        # middle 2 source & target
+        middle_2_source_graph2_v5 = self.transpose_graph_middle2source.forward(middle_graph2, adj=adj5_transfer_m2s,
+                                                                               relu=True)
+        middle_2_target_graph2_v5 = self.transpose_graph_middle2target.forward(middle_graph2, adj=adj6_transfer_m2t,
+                                                                               relu=True)
+        # source 2 middle target
+        source_2_target_graph2 = self.similarity_trans(source_graph2, target_graph2)
+        source_2_middle_graph2 = self.similarity_trans(source_graph2, middle_graph2)
+        # target 2 source middle
+        target_2_source_graph2 = self.similarity_trans(target_graph2, source_graph2)
+        target_2_middle_graph2 = self.similarity_trans(target_graph2, middle_graph2)
+        # middle 2 source target
+        middle_2_source_graph2 = self.similarity_trans(middle_graph2, source_graph2)
+        middle_2_target_graph2 = self.similarity_trans(middle_graph2, target_graph2)
+
+        ## concat
+        # print(source_graph1.size(), target_2_source_graph1.size(), )
+        source_graph2 = torch.cat(
+            (source_graph2, target_2_source_graph2, target_2_source_graph2_v5,
+             middle_2_source_graph2, middle_2_source_graph2_v5), dim=-1)
+        source_graph2 = self.fc_graph_source.forward(source_graph2, relu=True)
+        # target
+        target_graph2 = torch.cat(
+            (target_graph2, source_2_target_graph2, source_2_target_graph2_v5,
+             middle_2_target_graph2, middle_2_target_graph2_v5), dim=-1)
+        target_graph2 = self.fc_graph_target.forward(target_graph2, relu=True)
+        # middle
+        middle_graph2 = torch.cat((middle_graph2, source_2_middle_graph2, source_2_middle_graph2_v5,
+                                   target_2_middle_graph2, target_2_middle_graph2_v5), dim=-1)
+        middle_graph2 = self.fc_graph_middle.forward(middle_graph2, relu=True)
+
+
+        ### third task
+        source_graph3 = self.source_graph_conv1.forward(source_graph2, adj=adj2_source, relu=True)
+        target_graph3 = self.target_graph_conv1.forward(target_graph2, adj=adj1_target, relu=True)
+        middle_graph3 = self.target_graph_conv1.forward(middle_graph2, adj=adj4_middle, relu=True)
+
+        # source 2 target & middle
+        source_2_target_graph3_v5 = self.transpose_graph_source2target.forward(source_graph3, adj=adj3_transfer_s2t,
+                                                                               relu=True)
+        source_2_middle_graph3_v5 = self.transpose_graph_source2middle.forward(source_graph3, adj=adj5_transfer_s2m,
+                                                                               relu=True)
+        # target 2 source & middle
+        target_2_source_graph3_v5 = self.transpose_graph_target2source.forward(target_graph3, adj=adj3_transfer_t2s,
+                                                                               relu=True)
+        target_2_middle_graph3_v5 = self.transpose_graph_target2middle.forward(target_graph3, adj=adj6_transfer_t2m,
+                                                                               relu=True)
+        # middle 2 source & target
+        middle_2_source_graph3_v5 = self.transpose_graph_middle2source.forward(middle_graph3, adj=adj5_transfer_m2s,
+                                                                               relu=True)
+        middle_2_target_graph3_v5 = self.transpose_graph_middle2target.forward(middle_graph3, adj=adj6_transfer_m2t,
+                                                                               relu=True)
+        # source 2 middle target
+        source_2_target_graph3 = self.similarity_trans(source_graph3, target_graph3)
+        source_2_middle_graph3 = self.similarity_trans(source_graph3, middle_graph3)
+        # target 2 source middle
+        target_2_source_graph3 = self.similarity_trans(target_graph3, source_graph3)
+        target_2_middle_graph3 = self.similarity_trans(target_graph3, middle_graph3)
+        # middle 2 source target
+        middle_2_source_graph3 = self.similarity_trans(middle_graph3, source_graph3)
+        middle_2_target_graph3 = self.similarity_trans(middle_graph3, target_graph3)
+
+        ## concat
+        # print(source_graph1.size(), target_2_source_graph1.size(), )
+        source_graph3 = torch.cat(
+            (source_graph3, target_2_source_graph3, target_2_source_graph3_v5,
+             middle_2_source_graph3, middle_2_source_graph3_v5), dim=-1)
+        source_graph3 = self.fc_graph_source.forward(source_graph3, relu=True)
+        # target
+        target_graph3 = torch.cat(
+            (target_graph3, source_2_target_graph3, source_2_target_graph3_v5,
+             middle_2_target_graph3, middle_2_target_graph3_v5), dim=-1)
+        target_graph3 = self.fc_graph_target.forward(target_graph3, relu=True)
+        # middle
+        middle_graph3 = torch.cat((middle_graph3, source_2_middle_graph3, source_2_middle_graph3_v5,
+                                   target_2_middle_graph3, target_2_middle_graph3_v5), dim=-1)
+        middle_graph3 = self.fc_graph_middle.forward(middle_graph3, relu=True)
+
+        return source_graph3, target_graph3, middle_graph3, x
+
+    def similarity_trans(self,source,target):
+        sim = torch.matmul(F.normalize(target, p=2, dim=-1), F.normalize(source, p=2, dim=-1).transpose(-1, -2))
+        sim = F.softmax(sim, dim=-1)
+        return torch.matmul(sim, source)
+
+    def bottom_forward_source(self, input, source_graph):
+        # print('input size')
+        # print(input.size())
+        # print(source_graph.size())
+        graph = self.source_graph_2_fea.forward(source_graph, input)
+        x = self.source_skip_conv(input)
+        x = x + graph
+        x = self.source_semantic(x)
+        return x
+
+    def bottom_forward_target(self, input, target_graph):
+        graph = self.target_graph_2_fea.forward(target_graph, input)
+        x = self.target_skip_conv(input)
+        x = x + graph
+        x = self.semantic(x)
+        return x
+
+    def bottom_forward_middle(self, input, target_graph):
+        graph = self.middle_graph_2_fea.forward(target_graph, input)
+        x = self.middle_skip_conv(input)
+        x = x + graph
+        x = self.middle_semantic(x)
+        return x
+
+    def forward(self, input_source, input_target=None, input_middle=None, adj1_target=None, adj2_source=None,
+                adj3_transfer_s2t=None, adj3_transfer_t2s=None, adj4_middle=None,adj5_transfer_s2m=None,
+                adj6_transfer_t2m=None,adj5_transfer_m2s=None,adj6_transfer_m2t=None,):
+        if input_source is None and input_target is not None and input_middle is None:
+            # target
+            target_batch = input_target.size(0)
+            input = input_target
+
+            source_graph, target_graph, middle_graph, x = self.top_forward(input, adj1_target=adj1_target, adj2_source=adj2_source,
+                                                             adj3_transfer_s2t=adj3_transfer_s2t,
+                                                             adj3_transfer_t2s=adj3_transfer_t2s,
+                                                           adj4_middle=adj4_middle,
+                                                           adj5_transfer_s2m=adj5_transfer_s2m,
+                                                           adj6_transfer_t2m=adj6_transfer_t2m,
+                                                           adj5_transfer_m2s=adj5_transfer_m2s,
+                                                           adj6_transfer_m2t=adj6_transfer_m2t)
+
+            # source_x = self.bottom_forward_source(source_x, source_graph)
+            target_x = self.bottom_forward_target(x, target_graph)
+
+            target_x = F.upsample(target_x, size=input.size()[2:], mode='bilinear', align_corners=True)
+            return None, target_x, None
+
+        if input_source is not None and input_target is None and input_middle is None:
+            # source
+            source_batch = input_source.size(0)
+            source_list = range(source_batch)
+            input = input_source
+
+            source_graph, target_graph, middle_graph, x = self.top_forward(input, adj1_target=adj1_target,
+                                                                           adj2_source=adj2_source,
+                                                                           adj3_transfer_s2t=adj3_transfer_s2t,
+                                                                           adj3_transfer_t2s=adj3_transfer_t2s,
+                                                                           adj4_middle=adj4_middle,
+                                                                           adj5_transfer_s2m=adj5_transfer_s2m,
+                                                                           adj6_transfer_t2m=adj6_transfer_t2m,
+                                                                           adj5_transfer_m2s=adj5_transfer_m2s,
+                                                                           adj6_transfer_m2t=adj6_transfer_m2t)
+
+            source_x = self.bottom_forward_source(x, source_graph)
+            source_x = F.upsample(source_x, size=input.size()[2:], mode='bilinear', align_corners=True)
+            return source_x, None, None
+
+        if input_middle is not None and input_source is None and input_target is None:
+            # middle
+            input = input_middle
+
+            source_graph, target_graph, middle_graph, x = self.top_forward(input, adj1_target=adj1_target,
+                                                                           adj2_source=adj2_source,
+                                                                           adj3_transfer_s2t=adj3_transfer_s2t,
+                                                                           adj3_transfer_t2s=adj3_transfer_t2s,
+                                                                           adj4_middle=adj4_middle,
+                                                                           adj5_transfer_s2m=adj5_transfer_s2m,
+                                                                           adj6_transfer_t2m=adj6_transfer_t2m,
+                                                                           adj5_transfer_m2s=adj5_transfer_m2s,
+                                                                           adj6_transfer_m2t=adj6_transfer_m2t)
+
+            middle_x = self.bottom_forward_middle(x, source_graph)
+            middle_x = F.upsample(middle_x, size=input.size()[2:], mode='bilinear', align_corners=True)
+            return None, None, middle_x
+
+
+class deeplab_xception_end2end_3d_synbn(deeplab_xception_transfer_basemodel_savememory_synbn):
+    def __init__(self, nInputChannels=3, n_classes=20, os=16, input_channels=256, hidden_layers=128, out_channels=256,
+                 source_classes=7, middle_classes=18, transfer_graph=None):
+        super(deeplab_xception_end2end_3d_synbn, self).__init__(nInputChannels=nInputChannels,
+                                                                n_classes=n_classes,
+                                                                os=os, )
+        ### source graph
+        self.source_featuremap_2_graph = gcn.Featuremaps_to_Graph(input_channels=input_channels,
+                                                                  hidden_layers=hidden_layers,
+                                                                  nodes=source_classes)
+        self.source_graph_conv1 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.source_graph_conv2 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.source_graph_conv3 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+
+        self.source_graph_2_fea = gcn.Graph_to_Featuremaps_savemem(input_channels=input_channels,
+                                                                   output_channels=out_channels,
+                                                                   hidden_layers=hidden_layers, nodes=source_classes
+                                                                   )
+        self.source_skip_conv = nn.Sequential(*[nn.Conv2d(input_channels, input_channels, kernel_size=1),
+                                                nn.ReLU(True)])
+        self.source_semantic = nn.Conv2d(out_channels,source_classes,1)
+        self.middle_semantic = nn.Conv2d(out_channels, middle_classes, 1)
+
+        ### target graph 1
+        self.target_featuremap_2_graph = gcn.Featuremaps_to_Graph(input_channels=input_channels,
+                                                                  hidden_layers=hidden_layers,
+                                                                  nodes=n_classes)
+        self.target_graph_conv1 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.target_graph_conv2 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.target_graph_conv3 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+
+        self.target_graph_2_fea = gcn.Graph_to_Featuremaps_savemem(input_channels=input_channels,
+                                                                   output_channels=out_channels,
+                                                                   hidden_layers=hidden_layers, nodes=n_classes
+                                                                   )
+        self.target_skip_conv = nn.Sequential(*[nn.Conv2d(input_channels, input_channels, kernel_size=1),
+                                                nn.ReLU(True)])
+
+        ### middle
+        self.middle_featuremap_2_graph = gcn.Featuremaps_to_Graph(input_channels=input_channels,
+                                                                  hidden_layers=hidden_layers,
+                                                                  nodes=middle_classes)
+        self.middle_graph_conv1 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.middle_graph_conv2 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+        self.middle_graph_conv3 = gcn.GraphConvolution(hidden_layers, hidden_layers)
+
+        self.middle_graph_2_fea = gcn.Graph_to_Featuremaps_savemem(input_channels=input_channels,
+                                                                   output_channels=out_channels,
+                                                                   hidden_layers=hidden_layers, nodes=n_classes
+                                                                   )
+        self.middle_skip_conv = nn.Sequential(*[nn.Conv2d(input_channels, input_channels, kernel_size=1),
+                                                nn.ReLU(True)])
+
+        ### multi transpose
+        self.transpose_graph_source2target = gcn.Graph_trans(in_features=hidden_layers, out_features=hidden_layers,
+                                                             adj=transfer_graph,
+                                                             begin_nodes=source_classes, end_nodes=n_classes)
+        self.transpose_graph_target2source = gcn.Graph_trans(in_features=hidden_layers, out_features=hidden_layers,
+                                                             adj=transfer_graph,
+                                                             begin_nodes=n_classes, end_nodes=source_classes)
+
+        self.transpose_graph_middle2source = gcn.Graph_trans(in_features=hidden_layers, out_features=hidden_layers,
+                                                             adj=transfer_graph,
+                                                             begin_nodes=middle_classes, end_nodes=source_classes)
+        self.transpose_graph_middle2target = gcn.Graph_trans(in_features=hidden_layers, out_features=hidden_layers,
+                                                             adj=transfer_graph,
+                                                             begin_nodes=middle_classes, end_nodes=source_classes)
+
+        self.transpose_graph_source2middle = gcn.Graph_trans(in_features=hidden_layers, out_features=hidden_layers,
+                                                             adj=transfer_graph,
+                                                             begin_nodes=source_classes, end_nodes=middle_classes)
+        self.transpose_graph_target2middle = gcn.Graph_trans(in_features=hidden_layers, out_features=hidden_layers,
+                                                             adj=transfer_graph,
+                                                             begin_nodes=n_classes, end_nodes=middle_classes)
+
+
+        self.fc_graph_source = gcn.GraphConvolution(hidden_layers * 5, hidden_layers)
+        self.fc_graph_target = gcn.GraphConvolution(hidden_layers * 5, hidden_layers)
+        self.fc_graph_middle = gcn.GraphConvolution(hidden_layers * 5, hidden_layers)
+
+
+    def top_forward(self, input, adj1_target=None, adj2_source=None, adj3_transfer_s2t=None, adj3_transfer_t2s=None,
+            adj4_middle=None,adj5_transfer_s2m=None,adj6_transfer_t2m=None,adj5_transfer_m2s=None,adj6_transfer_m2t=None,):
+        x, low_level_features = self.xception_features(input)
+        # print(x.size())
+        x1 = self.aspp1(x)
+        x2 = self.aspp2(x)
+        x3 = self.aspp3(x)
+        x4 = self.aspp4(x)
+        x5 = self.global_avg_pool(x)
+        x5 = F.upsample(x5, size=x4.size()[2:], mode='bilinear', align_corners=True)
+
+        x = torch.cat((x1, x2, x3, x4, x5), dim=1)
+
+        x = self.concat_projection_conv1(x)
+        x = self.concat_projection_bn1(x)
+        x = self.relu(x)
+        # print(x.size())
+        x = F.upsample(x, size=low_level_features.size()[2:], mode='bilinear', align_corners=True)
+
+        low_level_features = self.feature_projection_conv1(low_level_features)
+        low_level_features = self.feature_projection_bn1(low_level_features)
+        low_level_features = self.relu(low_level_features)
+        # print(low_level_features.size())
+        # print(x.size())
+        x = torch.cat((x, low_level_features), dim=1)
+        x = self.decoder(x)
+
+        ### source graph
+        source_graph = self.source_featuremap_2_graph(x)
+        ### target source
+        target_graph = self.target_featuremap_2_graph(x)
+        ### middle source
+        middle_graph = self.middle_featuremap_2_graph(x)
+
+        ##### end2end multi task
+
+        ### first task
+        # print(source_graph.size(),target_graph.size())
+        source_graph1 = self.source_graph_conv1.forward(source_graph, adj=adj2_source, relu=True)
+        target_graph1 = self.target_graph_conv1.forward(target_graph, adj=adj1_target, relu=True)
+        middle_graph1 = self.target_graph_conv1.forward(middle_graph, adj=adj4_middle, relu=True)
+
+        # source 2 target & middle
+        source_2_target_graph1_v5 = self.transpose_graph_source2target.forward(source_graph1, adj=adj3_transfer_s2t,
+                                                                               relu=True)
+        source_2_middle_graph1_v5 = self.transpose_graph_source2middle.forward(source_graph1,adj=adj5_transfer_s2m,
+                                                                               relu=True)
+        # target 2 source & middle
+        target_2_source_graph1_v5 = self.transpose_graph_target2source.forward(target_graph1, adj=adj3_transfer_t2s,
+                                                                               relu=True)
+        target_2_middle_graph1_v5 = self.transpose_graph_target2middle.forward(target_graph1, adj=adj6_transfer_t2m,
+                                                                               relu=True)
+        # middle 2 source & target
+        middle_2_source_graph1_v5 = self.transpose_graph_middle2source.forward(middle_graph1, adj=adj5_transfer_m2s,
+                                                                               relu=True)
+        middle_2_target_graph1_v5 = self.transpose_graph_middle2target.forward(middle_graph1, adj=adj6_transfer_m2t,
+                                                                               relu=True)
+        # source 2 middle target
+        source_2_target_graph1 = self.similarity_trans(source_graph1, target_graph1)
+        source_2_middle_graph1 = self.similarity_trans(source_graph1, middle_graph1)
+        # target 2 source middle
+        target_2_source_graph1 = self.similarity_trans(target_graph1, source_graph1)
+        target_2_middle_graph1 = self.similarity_trans(target_graph1, middle_graph1)
+        # middle 2 source target
+        middle_2_source_graph1 = self.similarity_trans(middle_graph1, source_graph1)
+        middle_2_target_graph1 = self.similarity_trans(middle_graph1, target_graph1)
+
+        ## concat
+        # print(source_graph1.size(), target_2_source_graph1.size(), )
+        source_graph1 = torch.cat(
+            (source_graph1, target_2_source_graph1, target_2_source_graph1_v5,
+             middle_2_source_graph1, middle_2_source_graph1_v5), dim=-1)
+        source_graph1 = self.fc_graph_source.forward(source_graph1, relu=True)
+        # target
+        target_graph1 = torch.cat(
+            (target_graph1, source_2_target_graph1, source_2_target_graph1_v5,
+             middle_2_target_graph1, middle_2_target_graph1_v5), dim=-1)
+        target_graph1 = self.fc_graph_target.forward(target_graph1, relu=True)
+        # middle
+        middle_graph1 = torch.cat((middle_graph1, source_2_middle_graph1, source_2_middle_graph1_v5,
+                                   target_2_middle_graph1, target_2_middle_graph1_v5), dim=-1)
+        middle_graph1 = self.fc_graph_middle.forward(middle_graph1, relu=True)
+
+
+        ### seconde task
+        source_graph2 = self.source_graph_conv1.forward(source_graph1, adj=adj2_source, relu=True)
+        target_graph2 = self.target_graph_conv1.forward(target_graph1, adj=adj1_target, relu=True)
+        middle_graph2 = self.target_graph_conv1.forward(middle_graph1, adj=adj4_middle, relu=True)
+
+        # source 2 target & middle
+        source_2_target_graph2_v5 = self.transpose_graph_source2target.forward(source_graph2, adj=adj3_transfer_s2t,
+                                                                               relu=True)
+        source_2_middle_graph2_v5 = self.transpose_graph_source2middle.forward(source_graph2, adj=adj5_transfer_s2m,
+                                                                               relu=True)
+        # target 2 source & middle
+        target_2_source_graph2_v5 = self.transpose_graph_target2source.forward(target_graph2, adj=adj3_transfer_t2s,
+                                                                               relu=True)
+        target_2_middle_graph2_v5 = self.transpose_graph_target2middle.forward(target_graph2, adj=adj6_transfer_t2m,
+                                                                               relu=True)
+        # middle 2 source & target
+        middle_2_source_graph2_v5 = self.transpose_graph_middle2source.forward(middle_graph2, adj=adj5_transfer_m2s,
+                                                                               relu=True)
+        middle_2_target_graph2_v5 = self.transpose_graph_middle2target.forward(middle_graph2, adj=adj6_transfer_m2t,
+                                                                               relu=True)
+        # source 2 middle target
+        source_2_target_graph2 = self.similarity_trans(source_graph2, target_graph2)
+        source_2_middle_graph2 = self.similarity_trans(source_graph2, middle_graph2)
+        # target 2 source middle
+        target_2_source_graph2 = self.similarity_trans(target_graph2, source_graph2)
+        target_2_middle_graph2 = self.similarity_trans(target_graph2, middle_graph2)
+        # middle 2 source target
+        middle_2_source_graph2 = self.similarity_trans(middle_graph2, source_graph2)
+        middle_2_target_graph2 = self.similarity_trans(middle_graph2, target_graph2)
+
+        ## concat
+        # print(source_graph1.size(), target_2_source_graph1.size(), )
+        source_graph2 = torch.cat(
+            (source_graph2, target_2_source_graph2, target_2_source_graph2_v5,
+             middle_2_source_graph2, middle_2_source_graph2_v5), dim=-1)
+        source_graph2 = self.fc_graph_source.forward(source_graph2, relu=True)
+        # target
+        target_graph2 = torch.cat(
+            (target_graph2, source_2_target_graph2, source_2_target_graph2_v5,
+             middle_2_target_graph2, middle_2_target_graph2_v5), dim=-1)
+        target_graph2 = self.fc_graph_target.forward(target_graph2, relu=True)
+        # middle
+        middle_graph2 = torch.cat((middle_graph2, source_2_middle_graph2, source_2_middle_graph2_v5,
+                                   target_2_middle_graph2, target_2_middle_graph2_v5), dim=-1)
+        middle_graph2 = self.fc_graph_middle.forward(middle_graph2, relu=True)
+
+
+        ### third task
+        source_graph3 = self.source_graph_conv1.forward(source_graph2, adj=adj2_source, relu=True)
+        target_graph3 = self.target_graph_conv1.forward(target_graph2, adj=adj1_target, relu=True)
+        middle_graph3 = self.target_graph_conv1.forward(middle_graph2, adj=adj4_middle, relu=True)
+
+        # source 2 target & middle
+        source_2_target_graph3_v5 = self.transpose_graph_source2target.forward(source_graph3, adj=adj3_transfer_s2t,
+                                                                               relu=True)
+        source_2_middle_graph3_v5 = self.transpose_graph_source2middle.forward(source_graph3, adj=adj5_transfer_s2m,
+                                                                               relu=True)
+        # target 2 source & middle
+        target_2_source_graph3_v5 = self.transpose_graph_target2source.forward(target_graph3, adj=adj3_transfer_t2s,
+                                                                               relu=True)
+        target_2_middle_graph3_v5 = self.transpose_graph_target2middle.forward(target_graph3, adj=adj6_transfer_t2m,
+                                                                               relu=True)
+        # middle 2 source & target
+        middle_2_source_graph3_v5 = self.transpose_graph_middle2source.forward(middle_graph3, adj=adj5_transfer_m2s,
+                                                                               relu=True)
+        middle_2_target_graph3_v5 = self.transpose_graph_middle2target.forward(middle_graph3, adj=adj6_transfer_m2t,
+                                                                               relu=True)
+        # source 2 middle target
+        source_2_target_graph3 = self.similarity_trans(source_graph3, target_graph3)
+        source_2_middle_graph3 = self.similarity_trans(source_graph3, middle_graph3)
+        # target 2 source middle
+        target_2_source_graph3 = self.similarity_trans(target_graph3, source_graph3)
+        target_2_middle_graph3 = self.similarity_trans(target_graph3, middle_graph3)
+        # middle 2 source target
+        middle_2_source_graph3 = self.similarity_trans(middle_graph3, source_graph3)
+        middle_2_target_graph3 = self.similarity_trans(middle_graph3, target_graph3)
+
+        ## concat
+        # print(source_graph1.size(), target_2_source_graph1.size(), )
+        source_graph3 = torch.cat(
+            (source_graph3, target_2_source_graph3, target_2_source_graph3_v5,
+             middle_2_source_graph3, middle_2_source_graph3_v5), dim=-1)
+        source_graph3 = self.fc_graph_source.forward(source_graph3, relu=True)
+        # target
+        target_graph3 = torch.cat(
+            (target_graph3, source_2_target_graph3, source_2_target_graph3_v5,
+             middle_2_target_graph3, middle_2_target_graph3_v5), dim=-1)
+        target_graph3 = self.fc_graph_target.forward(target_graph3, relu=True)
+        # middle
+        middle_graph3 = torch.cat((middle_graph3, source_2_middle_graph3, source_2_middle_graph3_v5,
+                                   target_2_middle_graph3, target_2_middle_graph3_v5), dim=-1)
+        middle_graph3 = self.fc_graph_middle.forward(middle_graph3, relu=True)
+
+        return source_graph3, target_graph3, middle_graph3, x
+
+    def similarity_trans(self,source,target):
+        sim = torch.matmul(F.normalize(target, p=2, dim=-1), F.normalize(source, p=2, dim=-1).transpose(-1, -2))
+        sim = F.softmax(sim, dim=-1)
+        return torch.matmul(sim, source)
+
+    def bottom_forward_source(self, input, source_graph):
+        # print('input size')
+        # print(input.size())
+        # print(source_graph.size())
+        graph = self.source_graph_2_fea.forward(source_graph, input)
+        x = self.source_skip_conv(input)
+        x = x + graph
+        x = self.source_semantic(x)
+        return x
+
+    def bottom_forward_target(self, input, target_graph):
+        graph = self.target_graph_2_fea.forward(target_graph, input)
+        x = self.target_skip_conv(input)
+        x = x + graph
+        x = self.semantic(x)
+        return x
+
+    def bottom_forward_middle(self, input, target_graph):
+        graph = self.middle_graph_2_fea.forward(target_graph, input)
+        x = self.middle_skip_conv(input)
+        x = x + graph
+        x = self.middle_semantic(x)
+        return x
+
+    def forward(self, input_source, input_target=None, input_middle=None, adj1_target=None, adj2_source=None,
+                adj3_transfer_s2t=None, adj3_transfer_t2s=None, adj4_middle=None,adj5_transfer_s2m=None,
+                adj6_transfer_t2m=None,adj5_transfer_m2s=None,adj6_transfer_m2t=None,):
+
+        if input_source is None and input_target is not None and input_middle is None:
+            # target
+            target_batch = input_target.size(0)
+            input = input_target
+
+            source_graph, target_graph, middle_graph, x = self.top_forward(input, adj1_target=adj1_target, adj2_source=adj2_source,
+                                                             adj3_transfer_s2t=adj3_transfer_s2t,
+                                                             adj3_transfer_t2s=adj3_transfer_t2s,
+                                                           adj4_middle=adj4_middle,
+                                                           adj5_transfer_s2m=adj5_transfer_s2m,
+                                                           adj6_transfer_t2m=adj6_transfer_t2m,
+                                                           adj5_transfer_m2s=adj5_transfer_m2s,
+                                                           adj6_transfer_m2t=adj6_transfer_m2t)
+
+            # source_x = self.bottom_forward_source(source_x, source_graph)
+            target_x = self.bottom_forward_target(x, target_graph)
+
+            target_x = F.upsample(target_x, size=input.size()[2:], mode='bilinear', align_corners=True)
+            return None, target_x, None
+
+        if input_source is not None and input_target is None and input_middle is None:
+            # source
+            source_batch = input_source.size(0)
+            source_list = range(source_batch)
+            input = input_source
+
+            source_graph, target_graph, middle_graph, x = self.top_forward(input, adj1_target=adj1_target,
+                                                                           adj2_source=adj2_source,
+                                                                           adj3_transfer_s2t=adj3_transfer_s2t,
+                                                                           adj3_transfer_t2s=adj3_transfer_t2s,
+                                                                           adj4_middle=adj4_middle,
+                                                                           adj5_transfer_s2m=adj5_transfer_s2m,
+                                                                           adj6_transfer_t2m=adj6_transfer_t2m,
+                                                                           adj5_transfer_m2s=adj5_transfer_m2s,
+                                                                           adj6_transfer_m2t=adj6_transfer_m2t)
+
+            source_x = self.bottom_forward_source(x, source_graph)
+            source_x = F.upsample(source_x, size=input.size()[2:], mode='bilinear', align_corners=True)
+            return source_x, None, None
+
+        if input_middle is not None and input_source is None and input_target is None:
+            # middle
+            input = input_middle
+
+            source_graph, target_graph, middle_graph, x = self.top_forward(input, adj1_target=adj1_target,
+                                                                           adj2_source=adj2_source,
+                                                                           adj3_transfer_s2t=adj3_transfer_s2t,
+                                                                           adj3_transfer_t2s=adj3_transfer_t2s,
+                                                                           adj4_middle=adj4_middle,
+                                                                           adj5_transfer_s2m=adj5_transfer_s2m,
+                                                                           adj6_transfer_t2m=adj6_transfer_t2m,
+                                                                           adj5_transfer_m2s=adj5_transfer_m2s,
+                                                                           adj6_transfer_m2t=adj6_transfer_m2t)
+
+            middle_x = self.bottom_forward_middle(x, source_graph)
+            middle_x = F.upsample(middle_x, size=input.size()[2:], mode='bilinear', align_corners=True)
+            return None, None, middle_x
+
+
+if __name__ == '__main__':
+    net = deeplab_xception_end2end_3d()
+    net.freeze_totally_bn()
+    img1 = torch.rand((1,3,128,128))
+    img2 = torch.rand((1, 3, 128, 128))
+    a1 = torch.ones((1,1,7,20))
+    a2 = torch.ones((1,1,20,7))
+    net.eval()
+    net.forward(img1,img2,adj3_transfer_t2s=a2,adj3_transfer_s2t=a1)

TryYours-Virtual-Try-On/Graphonomy-master/networks/gcn.py

@@ -0,0 +1,279 @@
+import math
+import torch
+from torch.nn.parameter import Parameter
+import torch.nn as nn
+import torch.nn.functional as F
+from networks import graph
+# import pdb
+
+class GraphConvolution(nn.Module):
+
+    def __init__(self,in_features,out_features,bias=False):
+        super(GraphConvolution, self).__init__()
+        self.in_features = in_features
+        self.out_features = out_features
+        self.weight = Parameter(torch.FloatTensor(in_features,out_features))
+        if bias:
+            self.bias = Parameter(torch.FloatTensor(out_features))
+        else:
+            self.register_parameter('bias',None)
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        # stdv = 1./math.sqrt(self.weight(1))
+        # self.weight.data.uniform_(-stdv,stdv)
+        torch.nn.init.xavier_uniform_(self.weight)
+        # if self.bias is not None:
+        #     self.bias.data.uniform_(-stdv,stdv)
+
+    def forward(self, input,adj=None,relu=False):
+        support = torch.matmul(input, self.weight)
+        # print(support.size(),adj.size())
+        if adj is not None:
+            output = torch.matmul(adj, support)
+        else:
+            output = support
+        # print(output.size())
+        if self.bias is not None:
+            return output + self.bias
+        else:
+            if relu:
+                return F.relu(output)
+            else:
+                return output
+
+    def __repr__(self):
+        return self.__class__.__name__ + ' (' \
+               + str(self.in_features) + ' -> ' \
+               + str(self.out_features) + ')'
+
+class Featuremaps_to_Graph(nn.Module):
+
+    def __init__(self,input_channels,hidden_layers,nodes=7):
+        super(Featuremaps_to_Graph, self).__init__()
+        self.pre_fea = Parameter(torch.FloatTensor(input_channels,nodes))
+        self.weight = Parameter(torch.FloatTensor(input_channels,hidden_layers))
+        self.reset_parameters()
+
+    def forward(self, input):
+        n,c,h,w = input.size()
+        # print('fea input',input.size())
+        input1 = input.view(n,c,h*w)
+        input1 = input1.transpose(1,2) # n x hw x c
+        # print('fea input1', input1.size())
+        ############## Feature maps to node ################
+        fea_node = torch.matmul(input1,self.pre_fea) # n x hw x n_classes
+        weight_node = torch.matmul(input1,self.weight) # n x hw x hidden_layer
+        # softmax fea_node
+        fea_node = F.softmax(fea_node,dim=-1)
+        # print(fea_node.size(),weight_node.size())
+        graph_node = F.relu(torch.matmul(fea_node.transpose(1,2),weight_node))
+        return graph_node # n x n_class x hidden_layer
+
+    def reset_parameters(self):
+        for ww in self.parameters():
+            torch.nn.init.xavier_uniform_(ww)
+        # if self.bias is not None:
+        #     self.bias.data.uniform_(-stdv,stdv)
+
+class Featuremaps_to_Graph_transfer(nn.Module):
+
+    def __init__(self,input_channels,hidden_layers,nodes=7, source_nodes=20):
+        super(Featuremaps_to_Graph_transfer, self).__init__()
+        self.pre_fea = Parameter(torch.FloatTensor(input_channels,nodes))
+        self.weight = Parameter(torch.FloatTensor(input_channels,hidden_layers))
+        self.pre_fea_transfer = nn.Sequential(*[nn.Linear(source_nodes, source_nodes),nn.LeakyReLU(True),
+                                                nn.Linear(source_nodes, nodes), nn.LeakyReLU(True)])
+        self.reset_parameters()
+
+    def forward(self, input, source_pre_fea):
+        self.pre_fea.data = self.pre_fea_learn(source_pre_fea)
+        n,c,h,w = input.size()
+        # print('fea input',input.size())
+        input1 = input.view(n,c,h*w)
+        input1 = input1.transpose(1,2) # n x hw x c
+        # print('fea input1', input1.size())
+        ############## Feature maps to node ################
+        fea_node = torch.matmul(input1,self.pre_fea) # n x hw x n_classes
+        weight_node = torch.matmul(input1,self.weight) # n x hw x hidden_layer
+        # softmax fea_node
+        fea_node = F.softmax(fea_node,dim=1)
+        # print(fea_node.size(),weight_node.size())
+        graph_node = F.relu(torch.matmul(fea_node.transpose(1,2),weight_node))
+        return graph_node # n x n_class x hidden_layer
+
+    def pre_fea_learn(self, input):
+        pre_fea = self.pre_fea_transfer.forward(input.unsqueeze(0)).squeeze(0)
+        return self.pre_fea.data + pre_fea
+
+class Graph_to_Featuremaps(nn.Module):
+    # this is a special version
+    def __init__(self,input_channels,output_channels,hidden_layers,nodes=7):
+        super(Graph_to_Featuremaps, self).__init__()
+        self.node_fea = Parameter(torch.FloatTensor(input_channels+hidden_layers,1))
+        self.weight = Parameter(torch.FloatTensor(hidden_layers,output_channels))
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        for ww in self.parameters():
+            torch.nn.init.xavier_uniform_(ww)
+
+    def forward(self, input, res_feature):
+        '''
+
+        :param input: 1 x batch x nodes x hidden_layer
+        :param res_feature: batch x channels x h x w
+        :return:
+        '''
+        batchi,channeli,hi,wi = res_feature.size()
+        # print(res_feature.size())
+        # print(input.size())
+        try:
+            _,batch,nodes,hidden = input.size()
+        except:
+            # print(input.size())
+            input = input.unsqueeze(0)
+            _,batch, nodes, hidden = input.size()
+
+        assert batch == batchi
+        input1 = input.transpose(0,1).expand(batch,hi*wi,nodes,hidden)
+        res_feature_after_view = res_feature.view(batch,channeli,hi*wi).transpose(1,2)
+        res_feature_after_view1 = res_feature_after_view.unsqueeze(2).expand(batch,hi*wi,nodes,channeli)
+        new_fea = torch.cat((res_feature_after_view1,input1),dim=3)
+
+        # print(self.node_fea.size(),new_fea.size())
+        new_node = torch.matmul(new_fea, self.node_fea) # batch x hw x nodes x 1
+        new_weight = torch.matmul(input, self.weight)  # batch x node x channel
+        new_node = new_node.view(batch, hi*wi, nodes)
+        # 0721
+        new_node = F.softmax(new_node, dim=-1)
+        #
+        feature_out = torch.matmul(new_node,new_weight)
+        # print(feature_out.size())
+        feature_out = feature_out.transpose(2,3).contiguous().view(res_feature.size())
+        return F.relu(feature_out)
+
+class Graph_to_Featuremaps_savemem(nn.Module):
+    # this is a special version for saving gpu memory. The process is same as Graph_to_Featuremaps.
+    def __init__(self, input_channels, output_channels, hidden_layers, nodes=7):
+        super(Graph_to_Featuremaps_savemem, self).__init__()
+        self.node_fea_for_res = Parameter(torch.FloatTensor(input_channels, 1))
+        self.node_fea_for_hidden = Parameter(torch.FloatTensor(hidden_layers, 1))
+        self.weight = Parameter(torch.FloatTensor(hidden_layers,output_channels))
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        for ww in self.parameters():
+            torch.nn.init.xavier_uniform_(ww)
+
+    def forward(self, input, res_feature):
+        '''
+
+        :param input: 1 x batch x nodes x hidden_layer
+        :param res_feature: batch x channels x h x w
+        :return:
+        '''
+        batchi,channeli,hi,wi = res_feature.size()
+        # print(res_feature.size())
+        # print(input.size())
+        try:
+            _,batch,nodes,hidden = input.size()
+        except:
+            # print(input.size())
+            input = input.unsqueeze(0)
+            _,batch, nodes, hidden = input.size()
+
+        assert batch == batchi
+        input1 = input.transpose(0,1).expand(batch,hi*wi,nodes,hidden)
+        res_feature_after_view = res_feature.view(batch,channeli,hi*wi).transpose(1,2)
+        res_feature_after_view1 = res_feature_after_view.unsqueeze(2).expand(batch,hi*wi,nodes,channeli)
+        # new_fea = torch.cat((res_feature_after_view1,input1),dim=3)
+        ## sim
+        new_node1 = torch.matmul(res_feature_after_view1, self.node_fea_for_res)
+        new_node2 = torch.matmul(input1, self.node_fea_for_hidden)
+        new_node = new_node1 + new_node2
+        ## sim end
+        # print(self.node_fea.size(),new_fea.size())
+        # new_node = torch.matmul(new_fea, self.node_fea) # batch x hw x nodes x 1
+        new_weight = torch.matmul(input, self.weight) # batch x node x channel
+        new_node = new_node.view(batch, hi*wi, nodes)
+        # 0721
+        new_node = F.softmax(new_node, dim=-1)
+        #
+        feature_out = torch.matmul(new_node,new_weight)
+        # print(feature_out.size())
+        feature_out = feature_out.transpose(2,3).contiguous().view(res_feature.size())
+        return F.relu(feature_out)
+
+
+class Graph_trans(nn.Module):
+
+    def __init__(self,in_features,out_features,begin_nodes=7,end_nodes=2,bias=False,adj=None):
+        super(Graph_trans, self).__init__()
+        self.in_features = in_features
+        self.out_features = out_features
+        self.weight = Parameter(torch.FloatTensor(in_features,out_features))
+        if adj is not None:
+            h,w = adj.size()
+            assert (h == end_nodes) and (w == begin_nodes)
+            self.adj = torch.autograd.Variable(adj,requires_grad=False)
+        else:
+            self.adj = Parameter(torch.FloatTensor(end_nodes,begin_nodes))
+        if bias:
+            self.bias = Parameter(torch.FloatTensor(out_features))
+        else:
+            self.register_parameter('bias',None)
+        # self.reset_parameters()
+
+    def reset_parameters(self):
+        # stdv = 1./math.sqrt(self.weight(1))
+        # self.weight.data.uniform_(-stdv,stdv)
+        torch.nn.init.xavier_uniform_(self.weight)
+        # if self.bias is not None:
+        #     self.bias.data.uniform_(-stdv,stdv)
+
+    def forward(self, input, relu=False, adj_return=False, adj=None):
+        support = torch.matmul(input,self.weight)
+        # print(support.size(),self.adj.size())
+        if adj is None:
+            adj = self.adj
+        adj1 = self.norm_trans_adj(adj)
+        output = torch.matmul(adj1,support)
+        if adj_return:
+            output1 = F.normalize(output,p=2,dim=-1)
+            self.adj_mat = torch.matmul(output1,output1.transpose(-2,-1))
+        if self.bias is not None:
+            return output + self.bias
+        else:
+            if relu:
+                return F.relu(output)
+            else:
+                return output
+
+    def get_adj_mat(self):
+        adj = graph.normalize_adj_torch(F.relu(self.adj_mat))
+        return adj
+
+    def get_encode_adj(self):
+        return self.adj
+
+    def norm_trans_adj(self,adj):  # maybe can use softmax
+        adj = F.relu(adj)
+        r = F.softmax(adj,dim=-1)
+        # print(adj.size())
+        # row_sum = adj.sum(-1).unsqueeze(-1)
+        # d_mat = row_sum.expand(adj.size())
+        # r = torch.div(row_sum,d_mat)
+        # r[torch.isnan(r)] = 0
+
+        return r
+
+
+if __name__ == '__main__':
+
+    graph = torch.randn((7,128))
+    en = GraphConvolution(128,128)
+    a = en.forward(graph)
+    print(a)
+    # a = en.forward(graph,pred)
+    # print(a.size())

TryYours-Virtual-Try-On/Graphonomy-master/networks/graph.py

@@ -0,0 +1,261 @@
+import numpy as np
+import pickle as pkl
+import networkx as nx
+import scipy.sparse as sp
+import torch
+
+pascal_graph = {0:[0],
+                1:[1, 2],
+                2:[1, 2, 3, 5],
+                3:[2, 3, 4],
+                4:[3, 4],
+                5:[2, 5, 6],
+                6:[5, 6]}
+
+cihp_graph = {0: [],
+              1: [2, 13],
+              2: [1, 13],
+              3: [14, 15],
+              4: [13],
+              5: [6, 7, 9, 10, 11, 12, 14, 15],
+              6: [5, 7, 10, 11, 14, 15, 16, 17],
+              7: [5, 6, 9, 10, 11, 12, 14, 15],
+              8: [16, 17, 18, 19],
+              9: [5, 7, 10, 16, 17, 18, 19],
+              10:[5, 6, 7, 9, 11, 12, 13, 14, 15, 16, 17],
+              11:[5, 6, 7, 10, 13],
+              12:[5, 7, 10, 16, 17],
+              13:[1, 2, 4, 10, 11],
+              14:[3, 5, 6, 7, 10],
+              15:[3, 5, 6, 7, 10],
+              16:[6, 8, 9, 10, 12, 18],
+              17:[6, 8, 9, 10, 12, 19],
+              18:[8, 9, 16],
+              19:[8, 9, 17]}
+
+atr_graph = {0: [],
+              1: [2, 11],
+              2: [1, 11],
+              3: [11],
+              4: [5, 6, 7, 11, 14, 15, 17],
+              5: [4, 6, 7, 8, 12, 13],
+              6: [4,5,7,8,9,10,12,13],
+              7: [4,11,12,13,14,15],
+              8: [5,6],
+              9: [6, 12],
+              10:[6, 13],
+              11:[1,2,3,4,7,14,15,17],
+              12:[5,6,7,9],
+              13:[5,6,7,10],
+              14:[4,7,11,16],
+              15:[4,7,11,16],
+              16:[14,15],
+              17:[4,11],
+              }
+
+cihp2pascal_adj = np.array([[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
+                              [0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
+                              [0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
+                              [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0],
+                              [0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0],
+                              [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0],
+                              [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1]])
+
+cihp2pascal_nlp_adj = \
+    np.array([[ 1.,  0.35333052,  0.32727194,  0.17418084,  0.18757584,
+         0.40608522,  0.37503981,  0.35448462,  0.22598555,  0.23893579,
+         0.33064262,  0.28923404,  0.27986573,  0.4211553 ,  0.36915778,
+         0.41377746,  0.32485771,  0.37248222,  0.36865639,  0.41500332],
+       [ 0.39615879,  0.46201529,  0.52321467,  0.30826114,  0.25669527,
+         0.54747773,  0.3670523 ,  0.3901983 ,  0.27519473,  0.3433325 ,
+         0.52728509,  0.32771333,  0.34819325,  0.63882953,  0.68042925,
+         0.69368576,  0.63395791,  0.65344337,  0.59538781,  0.6071375 ],
+       [ 0.16373166,  0.21663339,  0.3053872 ,  0.28377612,  0.1372435 ,
+         0.4448808 ,  0.29479995,  0.31092595,  0.22703953,  0.33983576,
+         0.75778818,  0.2619818 ,  0.37069392,  0.35184867,  0.49877512,
+         0.49979437,  0.51853277,  0.52517541,  0.32517741,  0.32377309],
+       [ 0.32687232,  0.38482461,  0.37693463,  0.41610834,  0.20415749,
+         0.76749079,  0.35139853,  0.3787411 ,  0.28411737,  0.35155421,
+         0.58792618,  0.31141718,  0.40585111,  0.51189218,  0.82042737,
+         0.8342413 ,  0.70732188,  0.72752501,  0.60327325,  0.61431337],
+       [ 0.34069369,  0.34817292,  0.37525998,  0.36497069,  0.17841617,
+         0.69746208,  0.31731463,  0.34628951,  0.25167277,  0.32072379,
+         0.56711286,  0.24894776,  0.37000453,  0.52600859,  0.82483993,
+         0.84966274,  0.7033991 ,  0.73449378,  0.56649608,  0.58888791],
+       [ 0.28477487,  0.35139564,  0.42742352,  0.41664321,  0.20004676,
+         0.78566833,  0.42237487,  0.41048549,  0.37933812,  0.46542516,
+         0.62444759,  0.3274493 ,  0.49466009,  0.49314658,  0.71244233,
+         0.71497003,  0.8234787 ,  0.83566589,  0.62597135,  0.62626812],
+       [ 0.3011378 ,  0.31775977,  0.42922647,  0.36896257,  0.17597556,
+         0.72214655,  0.39162804,  0.38137872,  0.34980296,  0.43818419,
+         0.60879174,  0.26762545,  0.46271161,  0.51150476,  0.72318109,
+         0.73678399,  0.82620388,  0.84942166,  0.5943811 ,  0.60607602]])
+
+pascal2atr_nlp_adj = \
+    np.array([[ 1.,  0.35333052,  0.32727194,  0.18757584,  0.40608522,
+         0.27986573,  0.23893579,  0.27600672,  0.30964391,  0.36865639,
+         0.41500332,  0.4211553 ,  0.32485771,  0.37248222,  0.36915778,
+         0.41377746,  0.32006291,  0.28923404],
+       [ 0.39615879,  0.46201529,  0.52321467,  0.25669527,  0.54747773,
+         0.34819325,  0.3433325 ,  0.26603942,  0.45162929,  0.59538781,
+         0.6071375 ,  0.63882953,  0.63395791,  0.65344337,  0.68042925,
+         0.69368576,  0.44354613,  0.32771333],
+       [ 0.16373166,  0.21663339,  0.3053872 ,  0.1372435 ,  0.4448808 ,
+         0.37069392,  0.33983576,  0.26563416,  0.35443504,  0.32517741,
+         0.32377309,  0.35184867,  0.51853277,  0.52517541,  0.49877512,
+         0.49979437,  0.21750868,  0.2619818 ],
+       [ 0.32687232,  0.38482461,  0.37693463,  0.20415749,  0.76749079,
+         0.40585111,  0.35155421,  0.28271333,  0.52684576,  0.60327325,
+         0.61431337,  0.51189218,  0.70732188,  0.72752501,  0.82042737,
+         0.8342413 ,  0.40137029,  0.31141718],
+       [ 0.34069369,  0.34817292,  0.37525998,  0.17841617,  0.69746208,
+         0.37000453,  0.32072379,  0.27268885,  0.47426719,  0.56649608,
+         0.58888791,  0.52600859,  0.7033991 ,  0.73449378,  0.82483993,
+         0.84966274,  0.37830796,  0.24894776],
+       [ 0.28477487,  0.35139564,  0.42742352,  0.20004676,  0.78566833,
+         0.49466009,  0.46542516,  0.32662614,  0.55780359,  0.62597135,
+         0.62626812,  0.49314658,  0.8234787 ,  0.83566589,  0.71244233,
+         0.71497003,  0.41223219,  0.3274493 ],
+       [ 0.3011378 ,  0.31775977,  0.42922647,  0.17597556,  0.72214655,
+         0.46271161,  0.43818419,  0.3192333 ,  0.50979216,  0.5943811 ,
+         0.60607602,  0.51150476,  0.82620388,  0.84942166,  0.72318109,
+         0.73678399,  0.39259827,  0.26762545]])
+
+cihp2atr_nlp_adj = np.array([[ 1.,  0.35333052,  0.32727194,  0.18757584,  0.40608522,
+         0.27986573,  0.23893579,  0.27600672,  0.30964391,  0.36865639,
+         0.41500332,  0.4211553 ,  0.32485771,  0.37248222,  0.36915778,
+         0.41377746,  0.32006291,  0.28923404],
+       [ 0.35333052,  1.        ,  0.39206695,  0.42143438,  0.4736689 ,
+         0.47139544,  0.51999208,  0.38354847,  0.45628529,  0.46514124,
+         0.50083501,  0.4310595 ,  0.39371443,  0.4319752 ,  0.42938598,
+         0.46384034,  0.44833757,  0.6153155 ],
+       [ 0.32727194,  0.39206695,  1.        ,  0.32836702,  0.52603065,
+         0.39543695,  0.3622627 ,  0.43575346,  0.33866223,  0.45202552,
+         0.48421   ,  0.53669903,  0.47266611,  0.50925436,  0.42286557,
+         0.45403656,  0.37221304,  0.40999322],
+       [ 0.17418084,  0.46892601,  0.25774838,  0.31816231,  0.39330317,
+         0.34218382,  0.48253904,  0.22084125,  0.41335728,  0.52437572,
+         0.5191713 ,  0.33576117,  0.44230914,  0.44250678,  0.44330833,
+         0.43887264,  0.50693611,  0.39278795],
+       [ 0.18757584,  0.42143438,  0.32836702,  1.        ,  0.35030067,
+         0.30110947,  0.41055555,  0.34338879,  0.34336307,  0.37704433,
+         0.38810141,  0.34702081,  0.24171562,  0.25433078,  0.24696241,
+         0.2570884 ,  0.4465962 ,  0.45263213],
+       [ 0.40608522,  0.4736689 ,  0.52603065,  0.35030067,  1.        ,
+         0.54372584,  0.58300258,  0.56674191,  0.555266  ,  0.66599594,
+         0.68567555,  0.55716359,  0.62997328,  0.65638548,  0.61219615,
+         0.63183318,  0.54464151,  0.44293752],
+       [ 0.37503981,  0.50675565,  0.4761106 ,  0.37561813,  0.60419403,
+         0.77912403,  0.64595517,  0.85939662,  0.46037144,  0.52348817,
+         0.55875094,  0.37741886,  0.455671  ,  0.49434392,  0.38479954,
+         0.41804074,  0.47285709,  0.57236283],
+       [ 0.35448462,  0.50576632,  0.51030446,  0.35841033,  0.55106903,
+         0.50257274,  0.52591451,  0.4283053 ,  0.39991808,  0.42327211,
+         0.42853819,  0.42071825,  0.41240559,  0.42259136,  0.38125352,
+         0.3868255 ,  0.47604934,  0.51811717],
+       [ 0.22598555,  0.5053299 ,  0.36301185,  0.38002282,  0.49700941,
+         0.45625243,  0.62876479,  0.4112051 ,  0.33944371,  0.48322639,
+         0.50318714,  0.29207815,  0.38801966,  0.41119094,  0.29199072,
+         0.31021029,  0.41594871,  0.54961962],
+       [ 0.23893579,  0.51999208,  0.3622627 ,  0.41055555,  0.58300258,
+         0.68874251,  1.        ,  0.56977937,  0.49918447,  0.48484363,
+         0.51615925,  0.41222306,  0.49535971,  0.53134951,  0.3807616 ,
+         0.41050298,  0.48675801,  0.51112664],
+       [ 0.33064262,  0.306412  ,  0.60679935,  0.25592294,  0.58738706,
+         0.40379627,  0.39679161,  0.33618385,  0.39235148,  0.45474013,
+         0.4648476 ,  0.59306762,  0.58976007,  0.60778661,  0.55400397,
+         0.56551297,  0.3698029 ,  0.33860535],
+       [ 0.28923404,  0.6153155 ,  0.40999322,  0.45263213,  0.44293752,
+         0.60359359,  0.51112664,  0.46578181,  0.45656936,  0.38142307,
+         0.38525582,  0.33327223,  0.35360175,  0.36156453,  0.3384992 ,
+         0.34261229,  0.49297863,  1.        ],
+       [ 0.27986573,  0.47139544,  0.39543695,  0.30110947,  0.54372584,
+         1.        ,  0.68874251,  0.67765588,  0.48690078,  0.44010641,
+         0.44921156,  0.32321099,  0.48311542,  0.4982002 ,  0.39378102,
+         0.40297733,  0.45309735,  0.60359359],
+       [ 0.4211553 ,  0.4310595 ,  0.53669903,  0.34702081,  0.55716359,
+         0.32321099,  0.41222306,  0.25721705,  0.36633509,  0.5397475 ,
+         0.56429928,  1.        ,  0.55796926,  0.58842844,  0.57930828,
+         0.60410597,  0.41615326,  0.33327223],
+       [ 0.36915778,  0.42938598,  0.42286557,  0.24696241,  0.61219615,
+         0.39378102,  0.3807616 ,  0.28089866,  0.48450394,  0.77400821,
+         0.68813814,  0.57930828,  0.8856886 ,  0.81673412,  1.        ,
+         0.92279623,  0.46969152,  0.3384992 ],
+       [ 0.41377746,  0.46384034,  0.45403656,  0.2570884 ,  0.63183318,
+         0.40297733,  0.41050298,  0.332879  ,  0.48799542,  0.69231828,
+         0.77015091,  0.60410597,  0.79788484,  0.88232104,  0.92279623,
+         1.        ,  0.45685017,  0.34261229],
+       [ 0.32485771,  0.39371443,  0.47266611,  0.24171562,  0.62997328,
+         0.48311542,  0.49535971,  0.32477932,  0.51486622,  0.79353556,
+         0.69768738,  0.55796926,  1.        ,  0.92373745,  0.8856886 ,
+         0.79788484,  0.47883134,  0.35360175],
+       [ 0.37248222,  0.4319752 ,  0.50925436,  0.25433078,  0.65638548,
+         0.4982002 ,  0.53134951,  0.38057074,  0.52403969,  0.72035243,
+         0.78711147,  0.58842844,  0.92373745,  1.        ,  0.81673412,
+         0.88232104,  0.47109935,  0.36156453],
+       [ 0.36865639,  0.46514124,  0.45202552,  0.37704433,  0.66599594,
+         0.44010641,  0.48484363,  0.39636574,  0.50175258,  1.        ,
+         0.91320249,  0.5397475 ,  0.79353556,  0.72035243,  0.77400821,
+         0.69231828,  0.59087008,  0.38142307],
+       [ 0.41500332,  0.50083501,  0.48421,  0.38810141,  0.68567555,
+         0.44921156,  0.51615925,  0.45156472,  0.50438158,  0.91320249,
+         1.,  0.56429928,  0.69768738,  0.78711147,  0.68813814,
+         0.77015091,  0.57698754,  0.38525582]])
+
+
+
+def normalize_adj(adj):
+    """Symmetrically normalize adjacency matrix."""
+    adj = sp.coo_matrix(adj)
+    rowsum = np.array(adj.sum(1))
+    d_inv_sqrt = np.power(rowsum, -0.5).flatten()
+    d_inv_sqrt[np.isinf(d_inv_sqrt)] = 0.
+    d_mat_inv_sqrt = sp.diags(d_inv_sqrt)
+    return adj.dot(d_mat_inv_sqrt).transpose().dot(d_mat_inv_sqrt).tocoo()
+
+def preprocess_adj(adj):
+    """Preprocessing of adjacency matrix for simple GCN model and conversion to tuple representation."""
+    adj = nx.adjacency_matrix(nx.from_dict_of_lists(adj)) # return a adjacency matrix of adj ( type is numpy)
+    adj_normalized = normalize_adj(adj + sp.eye(adj.shape[0])) #
+    # return sparse_to_tuple(adj_normalized)
+    return adj_normalized.todense()
+
+def row_norm(inputs):
+    outputs = []
+    for x in inputs:
+        xsum = x.sum()
+        x = x / xsum
+        outputs.append(x)
+    return outputs
+
+
+def normalize_adj_torch(adj):
+    # print(adj.size())
+    if len(adj.size()) == 4:
+        new_r = torch.zeros(adj.size()).type_as(adj)
+        for i in range(adj.size(1)):
+            adj_item = adj[0,i]
+            rowsum = adj_item.sum(1)
+            d_inv_sqrt = rowsum.pow_(-0.5)
+            d_inv_sqrt[torch.isnan(d_inv_sqrt)] = 0
+            d_mat_inv_sqrt = torch.diag(d_inv_sqrt)
+            r = torch.matmul(torch.matmul(d_mat_inv_sqrt, adj_item), d_mat_inv_sqrt)
+            new_r[0,i,...] = r
+        return new_r
+    rowsum = adj.sum(1)
+    d_inv_sqrt = rowsum.pow_(-0.5)
+    d_inv_sqrt[torch.isnan(d_inv_sqrt)] = 0
+    d_mat_inv_sqrt = torch.diag(d_inv_sqrt)
+    r = torch.matmul(torch.matmul(d_mat_inv_sqrt,adj),d_mat_inv_sqrt)
+    return r
+
+# def row_norm(adj):
+
+
+
+
+if __name__ == '__main__':
+    a= row_norm(cihp2pascal_adj)
+    print(a)
+    print(cihp2pascal_adj)
+    # print(a.shape)